falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
97609 Commits
32 Branches
380MB
Tree: 3a41bac4e2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3a41bac4e2'
${ noResults }
FFmpeg/libavcodec/cbs_h2645.c

1623 lines
48KB
Raw Blame History 

  1. /*

  2.  * This file is part of FFmpeg.

  3.  *

  4.  * FFmpeg is free software; you can redistribute it and/or

  5.  * modify it under the terms of the GNU Lesser General Public

  6.  * License as published by the Free Software Foundation; either

  7.  * version 2.1 of the License, or (at your option) any later version.

  8.  *

  9.  * FFmpeg is distributed in the hope that it will be useful,

  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  12.  * Lesser General Public License for more details.

  13.  *

  14.  * You should have received a copy of the GNU Lesser General Public

  15.  * License along with FFmpeg; if not, write to the Free Software

  16.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  17.  */

  18. 

  19. #include "libavutil/attributes.h"

  20. #include "libavutil/avassert.h"

  21. 

  22. #include "bytestream.h"

  23. #include "cbs.h"

  24. #include "cbs_internal.h"

  25. #include "cbs_h264.h"

  26. #include "cbs_h265.h"

  27. #include "h264.h"

  28. #include "h264_sei.h"

  29. #include "h2645_parse.h"

  30. #include "hevc.h"

  31. #include "hevc_sei.h"

  32. 

  33. 

  34. static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc,

  35.                               const char *name, const int *subscripts,

  36.                               uint32_t *write_to,

  37.                               uint32_t range_min, uint32_t range_max)

  38. {

  39.     uint32_t value;

  40.     int position, i, j;

  41.     unsigned int k;

  42.     char bits[65];

  43. 

  44.     position = get_bits_count(gbc);

  45. 

  46.     for (i = 0; i < 32; i++) {

  47.         if (get_bits_left(gbc) < i + 1) {

  48.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid ue-golomb code at "

  49.                    "%s: bitstream ended.\n", name);

  50.             return AVERROR_INVALIDDATA;

  51.         }

  52.         k = get_bits1(gbc);

  53.         bits[i] = k ? '1' : '0';

  54.         if (k)

  55.             break;

  56.     }

  57.     if (i >= 32) {

  58.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid ue-golomb code at "

  59.                "%s: more than 31 zeroes.\n", name);

  60.         return AVERROR_INVALIDDATA;

  61.     }

  62.     value = 1;

  63.     for (j = 0; j < i; j++) {

  64.         k = get_bits1(gbc);

  65.         bits[i + j + 1] = k ? '1' : '0';

  66.         value = value << 1 | k;

  67.     }

  68.     bits[i + j + 1] = 0;

  69.     --value;

  70. 

  71.     if (ctx->trace_enable)

  72.         ff_cbs_trace_syntax_element(ctx, position, name, subscripts,

  73.                                     bits, value);

  74. 

  75.     if (value < range_min || value > range_max) {

  76.         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

  77.                "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",

  78.                name, value, range_min, range_max);

  79.         return AVERROR_INVALIDDATA;

  80.     }

  81. 

  82.     *write_to = value;

  83.     return 0;

  84. }

  85. 

  86. static int cbs_read_se_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc,

  87.                               const char *name, const int *subscripts,

  88.                               int32_t *write_to,

  89.                               int32_t range_min, int32_t range_max)

  90. {

  91.     int32_t value;

  92.     int position, i, j;

  93.     unsigned int k;

  94.     uint32_t v;

  95.     char bits[65];

  96. 

  97.     position = get_bits_count(gbc);

  98. 

  99.     for (i = 0; i < 32; i++) {

  100.         if (get_bits_left(gbc) < i + 1) {

  101.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid se-golomb code at "

  102.                    "%s: bitstream ended.\n", name);

  103.             return AVERROR_INVALIDDATA;

  104.         }

  105.         k = get_bits1(gbc);

  106.         bits[i] = k ? '1' : '0';

  107.         if (k)

  108.             break;

  109.     }

  110.     if (i >= 32) {

  111.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid se-golomb code at "

  112.                "%s: more than 31 zeroes.\n", name);

  113.         return AVERROR_INVALIDDATA;

  114.     }

  115.     v = 1;

  116.     for (j = 0; j < i; j++) {

  117.         k = get_bits1(gbc);

  118.         bits[i + j + 1] = k ? '1' : '0';

  119.         v = v << 1 | k;

  120.     }

  121.     bits[i + j + 1] = 0;

  122.     if (v & 1)

  123.         value = -(int32_t)(v / 2);

  124.     else

  125.         value = v / 2;

  126. 

  127.     if (ctx->trace_enable)

  128.         ff_cbs_trace_syntax_element(ctx, position, name, subscripts,

  129.                                     bits, value);

  130. 

  131.     if (value < range_min || value > range_max) {

  132.         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

  133.                "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",

  134.                name, value, range_min, range_max);

  135.         return AVERROR_INVALIDDATA;

  136.     }

  137. 

  138.     *write_to = value;

  139.     return 0;

  140. }

  141. 

  142. static int cbs_write_ue_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc,

  143.                                const char *name, const int *subscripts,

  144.                                uint32_t value,

  145.                                uint32_t range_min, uint32_t range_max)

  146. {

  147.     int len;

  148. 

  149.     if (value < range_min || value > range_max) {

  150.         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

  151.                "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",

  152.                name, value, range_min, range_max);

  153.         return AVERROR_INVALIDDATA;

  154.     }

  155.     av_assert0(value != UINT32_MAX);

  156. 

  157.     len = av_log2(value + 1);

  158.     if (put_bits_left(pbc) < 2 * len + 1)

  159.         return AVERROR(ENOSPC);

  160. 

  161.     if (ctx->trace_enable) {

  162.         char bits[65];

  163.         int i;

  164. 

  165.         for (i = 0; i < len; i++)

  166.             bits[i] = '0';

  167.         bits[len] = '1';

  168.         for (i = 0; i < len; i++)

  169.             bits[len + i + 1] = (value + 1) >> (len - i - 1) & 1 ? '1' : '0';

  170.         bits[len + len + 1] = 0;

  171. 

  172.         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),

  173.                                     name, subscripts, bits, value);

  174.     }

  175. 

  176.     put_bits(pbc, len, 0);

  177.     if (len + 1 < 32)

  178.         put_bits(pbc, len + 1, value + 1);

  179.     else

  180.         put_bits32(pbc, value + 1);

  181. 

  182.     return 0;

  183. }

  184. 

  185. static int cbs_write_se_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc,

  186.                                const char *name, const int *subscripts,

  187.                                int32_t value,

  188.                                int32_t range_min, int32_t range_max)

  189. {

  190.     int len;

  191.     uint32_t uvalue;

  192. 

  193.     if (value < range_min || value > range_max) {

  194.         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

  195.                "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",

  196.                name, value, range_min, range_max);

  197.         return AVERROR_INVALIDDATA;

  198.     }

  199.     av_assert0(value != INT32_MIN);

  200. 

  201.     if (value == 0)

  202.         uvalue = 0;

  203.     else if (value > 0)

  204.         uvalue = 2 * (uint32_t)value - 1;

  205.     else

  206.         uvalue = 2 * (uint32_t)-value;

  207. 

  208.     len = av_log2(uvalue + 1);

  209.     if (put_bits_left(pbc) < 2 * len + 1)

  210.         return AVERROR(ENOSPC);

  211. 

  212.     if (ctx->trace_enable) {

  213.         char bits[65];

  214.         int i;

  215. 

  216.         for (i = 0; i < len; i++)

  217.             bits[i] = '0';

  218.         bits[len] = '1';

  219.         for (i = 0; i < len; i++)

  220.             bits[len + i + 1] = (uvalue + 1) >> (len - i - 1) & 1 ? '1' : '0';

  221.         bits[len + len + 1] = 0;

  222. 

  223.         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),

  224.                                     name, subscripts, bits, value);

  225.     }

  226. 

  227.     put_bits(pbc, len, 0);

  228.     if (len + 1 < 32)

  229.         put_bits(pbc, len + 1, uvalue + 1);

  230.     else

  231.         put_bits32(pbc, uvalue + 1);

  232. 

  233.     return 0;

  234. }

  235. 

  236. // payload_extension_present() - true if we are before the last 1-bit

  237. // in the payload structure, which must be in the last byte.

  238. static int cbs_h265_payload_extension_present(GetBitContext *gbc, uint32_t payload_size,

  239.                                               int cur_pos)

  240. {

  241.     int bits_left = payload_size * 8 - cur_pos;

  242.     return (bits_left > 0 &&

  243.             (bits_left > 7 || show_bits(gbc, bits_left) & MAX_UINT_BITS(bits_left - 1)));

  244. }

  245. 

  246. #define HEADER(name) do { \

  247.         ff_cbs_trace_header(ctx, name); \

  248.     } while (0)

  249. 

  250. #define CHECK(call) do { \

  251.         err = (call); \

  252.         if (err < 0) \

  253.             return err; \

  254.     } while (0)

  255. 

  256. #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name

  257. #define FUNC_H264(rw, name) FUNC_NAME(rw, h264, name)

  258. #define FUNC_H265(rw, name) FUNC_NAME(rw, h265, name)

  259. 

  260. #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)

  261. 

  262. #define u(width, name, range_min, range_max) \

  263.         xu(width, name, current->name, range_min, range_max, 0, )

  264. #define ub(width, name) \

  265.         xu(width, name, current->name, 0, MAX_UINT_BITS(width), 0, )

  266. #define flag(name) ub(1, name)

  267. #define ue(name, range_min, range_max) \

  268.         xue(name, current->name, range_min, range_max, 0, )

  269. #define i(width, name, range_min, range_max) \

  270.         xi(width, name, current->name, range_min, range_max, 0, )

  271. #define ib(width, name) \

  272.         xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), 0, )

  273. #define se(name, range_min, range_max) \

  274.         xse(name, current->name, range_min, range_max, 0, )

  275. 

  276. #define us(width, name, range_min, range_max, subs, ...) \

  277.         xu(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)

  278. #define ubs(width, name, subs, ...) \

  279.         xu(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)

  280. #define flags(name, subs, ...) \

  281.         xu(1, name, current->name, 0, 1, subs, __VA_ARGS__)

  282. #define ues(name, range_min, range_max, subs, ...) \

  283.         xue(name, current->name, range_min, range_max, subs, __VA_ARGS__)

  284. #define is(width, name, range_min, range_max, subs, ...) \

  285.         xi(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)

  286. #define ibs(width, name, subs, ...) \

  287.         xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), subs, __VA_ARGS__)

  288. #define ses(name, range_min, range_max, subs, ...) \

  289.         xse(name, current->name, range_min, range_max, subs, __VA_ARGS__)

  290. 

  291. #define fixed(width, name, value) do { \

  292.         av_unused uint32_t fixed_value = value; \

  293.         xu(width, name, fixed_value, value, value, 0, ); \

  294.     } while (0)

  295. 

  296. 

  297. #define READ

  298. #define READWRITE read

  299. #define RWContext GetBitContext

  300. 

  301. #define xu(width, name, var, range_min, range_max, subs, ...) do { \

  302.         uint32_t value; \

  303.         CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \

  304.                                    SUBSCRIPTS(subs, __VA_ARGS__), \

  305.                                    &value, range_min, range_max)); \

  306.         var = value; \

  307.     } while (0)

  308. #define xue(name, var, range_min, range_max, subs, ...) do { \

  309.         uint32_t value; \

  310.         CHECK(cbs_read_ue_golomb(ctx, rw, #name, \

  311.                                  SUBSCRIPTS(subs, __VA_ARGS__), \

  312.                                  &value, range_min, range_max)); \

  313.         var = value; \

  314.     } while (0)

  315. #define xi(width, name, var, range_min, range_max, subs, ...) do { \

  316.         int32_t value; \

  317.         CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \

  318.                                  SUBSCRIPTS(subs, __VA_ARGS__), \

  319.                                  &value, range_min, range_max)); \

  320.         var = value; \

  321.     } while (0)

  322. #define xse(name, var, range_min, range_max, subs, ...) do { \

  323.         int32_t value; \

  324.         CHECK(cbs_read_se_golomb(ctx, rw, #name, \

  325.                                  SUBSCRIPTS(subs, __VA_ARGS__), \

  326.                                  &value, range_min, range_max)); \

  327.         var = value; \

  328.     } while (0)

  329. 

  330. 

  331. #define infer(name, value) do { \

  332.         current->name = value; \

  333.     } while (0)

  334. 

  335. static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)

  336. {

  337.     int bits_left = get_bits_left(gbc);

  338.     if (bits_left > 8)

  339.         return 1;

  340.     if (bits_left == 0)

  341.         return 0;

  342.     if (show_bits(gbc, bits_left) & MAX_UINT_BITS(bits_left - 1))

  343.         return 1;

  344.     return 0;

  345. }

  346. 

  347. #define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw))

  348. 

  349. #define byte_alignment(rw) (get_bits_count(rw) % 8)

  350. 

  351. #define allocate(name, size) do { \

  352.         name ## _ref = av_buffer_allocz(size + \

  353.                                         AV_INPUT_BUFFER_PADDING_SIZE); \

  354.         if (!name ## _ref) \

  355.             return AVERROR(ENOMEM); \

  356.         name = name ## _ref->data; \

  357.     } while (0)

  358. 

  359. #define FUNC(name) FUNC_H264(READWRITE, name)

  360. #include "cbs_h264_syntax_template.c"

  361. #undef FUNC

  362. 

  363. #define FUNC(name) FUNC_H265(READWRITE, name)

  364. #include "cbs_h265_syntax_template.c"

  365. #undef FUNC

  366. 

  367. #undef READ

  368. #undef READWRITE

  369. #undef RWContext

  370. #undef xu

  371. #undef xi

  372. #undef xue

  373. #undef xse

  374. #undef infer

  375. #undef more_rbsp_data

  376. #undef byte_alignment

  377. #undef allocate

  378. 

  379. 

  380. #define WRITE

  381. #define READWRITE write

  382. #define RWContext PutBitContext

  383. 

  384. #define xu(width, name, var, range_min, range_max, subs, ...) do { \

  385.         uint32_t value = var; \

  386.         CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \

  387.                                     SUBSCRIPTS(subs, __VA_ARGS__), \

  388.                                     value, range_min, range_max)); \

  389.     } while (0)

  390. #define xue(name, var, range_min, range_max, subs, ...) do { \

  391.         uint32_t value = var; \

  392.         CHECK(cbs_write_ue_golomb(ctx, rw, #name, \

  393.                                   SUBSCRIPTS(subs, __VA_ARGS__), \

  394.                                   value, range_min, range_max)); \

  395.     } while (0)

  396. #define xi(width, name, var, range_min, range_max, subs, ...) do { \

  397.         int32_t value = var; \

  398.         CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \

  399.                                   SUBSCRIPTS(subs, __VA_ARGS__), \

  400.                                   value, range_min, range_max)); \

  401.     } while (0)

  402. #define xse(name, var, range_min, range_max, subs, ...) do { \

  403.         int32_t value = var; \

  404.         CHECK(cbs_write_se_golomb(ctx, rw, #name, \

  405.                                   SUBSCRIPTS(subs, __VA_ARGS__), \

  406.                                   value, range_min, range_max)); \

  407.     } while (0)

  408. 

  409. #define infer(name, value) do { \

  410.         if (current->name != (value)) { \

  411.             av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \

  412.                    "%s does not match inferred value: " \

  413.                    "%"PRId64", but should be %"PRId64".\n", \

  414.                    #name, (int64_t)current->name, (int64_t)(value)); \

  415.         } \

  416.     } while (0)

  417. 

  418. #define more_rbsp_data(var) (var)

  419. 

  420. #define byte_alignment(rw) (put_bits_count(rw) % 8)

  421. 

  422. #define allocate(name, size) do { \

  423.         if (!name) { \

  424.             av_log(ctx->log_ctx, AV_LOG_ERROR, "%s must be set " \

  425.                    "for writing.\n", #name); \

  426.             return AVERROR_INVALIDDATA; \

  427.         } \

  428.     } while (0)

  429. 

  430. #define FUNC(name) FUNC_H264(READWRITE, name)

  431. #include "cbs_h264_syntax_template.c"

  432. #undef FUNC

  433. 

  434. #define FUNC(name) FUNC_H265(READWRITE, name)

  435. #include "cbs_h265_syntax_template.c"

  436. #undef FUNC

  437. 

  438. #undef WRITE

  439. #undef READWRITE

  440. #undef RWContext

  441. #undef xu

  442. #undef xi

  443. #undef xue

  444. #undef xse

  445. #undef u

  446. #undef i

  447. #undef flag

  448. #undef ue

  449. #undef se

  450. #undef infer

  451. #undef more_rbsp_data

  452. #undef byte_alignment

  453. #undef allocate

  454. 

  455. 

  456. static void cbs_h264_free_pps(void *opaque, uint8_t *content)

  457. {

  458.     H264RawPPS *pps = (H264RawPPS*)content;

  459.     av_buffer_unref(&pps->slice_group_id_ref);

  460.     av_freep(&content);

  461. }

  462. 

  463. static void cbs_h264_free_sei_payload(H264RawSEIPayload *payload)

  464. {

  465.     switch (payload->payload_type) {

  466.     case H264_SEI_TYPE_BUFFERING_PERIOD:

  467.     case H264_SEI_TYPE_PIC_TIMING:

  468.     case H264_SEI_TYPE_PAN_SCAN_RECT:

  469.     case H264_SEI_TYPE_RECOVERY_POINT:

  470.     case H264_SEI_TYPE_DISPLAY_ORIENTATION:

  471.     case H264_SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME:

  472.     case H264_SEI_TYPE_ALTERNATIVE_TRANSFER:

  473.         break;

  474.     case H264_SEI_TYPE_USER_DATA_REGISTERED:

  475.         av_buffer_unref(&payload->payload.user_data_registered.data_ref);

  476.         break;

  477.     case H264_SEI_TYPE_USER_DATA_UNREGISTERED:

  478.         av_buffer_unref(&payload->payload.user_data_unregistered.data_ref);

  479.         break;

  480.     default:

  481.         av_buffer_unref(&payload->payload.other.data_ref);

  482.         break;

  483.     }

  484. }

  485. 

  486. static void cbs_h264_free_sei(void *opaque, uint8_t *content)

  487. {

  488.     H264RawSEI *sei = (H264RawSEI*)content;

  489.     int i;

  490.     for (i = 0; i < sei->payload_count; i++)

  491.         cbs_h264_free_sei_payload(&sei->payload[i]);

  492.     av_freep(&content);

  493. }

  494. 

  495. static void cbs_h264_free_slice(void *opaque, uint8_t *content)

  496. {

  497.     H264RawSlice *slice = (H264RawSlice*)content;

  498.     av_buffer_unref(&slice->data_ref);

  499.     av_freep(&content);

  500. }

  501. 

  502. static void cbs_h265_free_vps(void *opaque, uint8_t *content)

  503. {

  504.     H265RawVPS *vps = (H265RawVPS*)content;

  505.     av_buffer_unref(&vps->extension_data.data_ref);

  506.     av_freep(&content);

  507. }

  508. 

  509. static void cbs_h265_free_sps(void *opaque, uint8_t *content)

  510. {

  511.     H265RawSPS *sps = (H265RawSPS*)content;

  512.     av_buffer_unref(&sps->extension_data.data_ref);

  513.     av_freep(&content);

  514. }

  515. 

  516. static void cbs_h265_free_pps(void *opaque, uint8_t *content)

  517. {

  518.     H265RawPPS *pps = (H265RawPPS*)content;

  519.     av_buffer_unref(&pps->extension_data.data_ref);

  520.     av_freep(&content);

  521. }

  522. 

  523. static void cbs_h265_free_slice(void *opaque, uint8_t *content)

  524. {

  525.     H265RawSlice *slice = (H265RawSlice*)content;

  526.     av_buffer_unref(&slice->data_ref);

  527.     av_freep(&content);

  528. }

  529. 

  530. static void cbs_h265_free_sei_payload(H265RawSEIPayload *payload)

  531. {

  532.     switch (payload->payload_type) {

  533.     case HEVC_SEI_TYPE_BUFFERING_PERIOD:

  534.     case HEVC_SEI_TYPE_PICTURE_TIMING:

  535.     case HEVC_SEI_TYPE_PAN_SCAN_RECT:

  536.     case HEVC_SEI_TYPE_RECOVERY_POINT:

  537.     case HEVC_SEI_TYPE_DISPLAY_ORIENTATION:

  538.     case HEVC_SEI_TYPE_ACTIVE_PARAMETER_SETS:

  539.     case HEVC_SEI_TYPE_DECODED_PICTURE_HASH:

  540.     case HEVC_SEI_TYPE_TIME_CODE:

  541.     case HEVC_SEI_TYPE_MASTERING_DISPLAY_INFO:

  542.     case HEVC_SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO:

  543.     case HEVC_SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS:

  544.     case HEVC_SEI_TYPE_ALPHA_CHANNEL_INFO:

  545.         break;

  546.     case HEVC_SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35:

  547.         av_buffer_unref(&payload->payload.user_data_registered.data_ref);

  548.         break;

  549.     case HEVC_SEI_TYPE_USER_DATA_UNREGISTERED:

  550.         av_buffer_unref(&payload->payload.user_data_unregistered.data_ref);

  551.         break;

  552.     default:

  553.         av_buffer_unref(&payload->payload.other.data_ref);

  554.         break;

  555.     }

  556. }

  557. 

  558. static void cbs_h265_free_sei(void *opaque, uint8_t *content)

  559. {

  560.     H265RawSEI *sei = (H265RawSEI*)content;

  561.     int i;

  562.     for (i = 0; i < sei->payload_count; i++)

  563.         cbs_h265_free_sei_payload(&sei->payload[i]);

  564.     av_freep(&content);

  565. }

  566. 

  567. static int cbs_h2645_fragment_add_nals(CodedBitstreamContext *ctx,

  568.                                        CodedBitstreamFragment *frag,

  569.                                        const H2645Packet *packet)

  570. {

  571.     int err, i;

  572. 

  573.     for (i = 0; i < packet->nb_nals; i++) {

  574.         const H2645NAL *nal = &packet->nals[i];

  575.         AVBufferRef *ref;

  576.         size_t size = nal->size;

  577. 

  578.         if (nal->nuh_layer_id > 0)

  579.             continue;

  580. 

  581.         // Remove trailing zeroes.

  582.         while (size > 0 && nal->data[size - 1] == 0)

  583.             --size;

  584.         if (size == 0) {

  585.             av_log(ctx->log_ctx, AV_LOG_VERBOSE, "Discarding empty 0 NAL unit\n");

  586.             continue;

  587.         }

  588. 

  589.         ref = (nal->data == nal->raw_data) ? frag->data_ref

  590.                                            : packet->rbsp.rbsp_buffer_ref;

  591. 

  592.         err = ff_cbs_insert_unit_data(ctx, frag, -1, nal->type,

  593.                             (uint8_t*)nal->data, size, ref);

  594.         if (err < 0)

  595.             return err;

  596.     }

  597. 

  598.     return 0;

  599. }

  600. 

  601. static int cbs_h2645_split_fragment(CodedBitstreamContext *ctx,

  602.                                     CodedBitstreamFragment *frag,

  603.                                     int header)

  604. {

  605.     enum AVCodecID codec_id = ctx->codec->codec_id;

  606.     CodedBitstreamH2645Context *priv = ctx->priv_data;

  607.     GetByteContext gbc;

  608.     int err;

  609. 

  610.     av_assert0(frag->data && frag->nb_units == 0);

  611.     if (frag->data_size == 0)

  612.         return 0;

  613. 

  614.     if (header && frag->data[0] && codec_id == AV_CODEC_ID_H264) {

  615.         // AVCC header.

  616.         size_t size, start, end;

  617.         int i, count, version;

  618. 

  619.         priv->mp4 = 1;

  620. 

  621.         bytestream2_init(&gbc, frag->data, frag->data_size);

  622. 

  623.         if (bytestream2_get_bytes_left(&gbc) < 6)

  624.             return AVERROR_INVALIDDATA;

  625. 

  626.         version = bytestream2_get_byte(&gbc);

  627.         if (version != 1) {

  628.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid AVCC header: "

  629.                    "first byte %u.\n", version);

  630.             return AVERROR_INVALIDDATA;

  631.         }

  632. 

  633.         bytestream2_skip(&gbc, 3);

  634.         priv->nal_length_size = (bytestream2_get_byte(&gbc) & 3) + 1;

  635. 

  636.         // SPS array.

  637.         count = bytestream2_get_byte(&gbc) & 0x1f;

  638.         start = bytestream2_tell(&gbc);

  639.         for (i = 0; i < count; i++) {

  640.             if (bytestream2_get_bytes_left(&gbc) < 2 * (count - i))

  641.                 return AVERROR_INVALIDDATA;

  642.             size = bytestream2_get_be16(&gbc);

  643.             if (bytestream2_get_bytes_left(&gbc) < size)

  644.                 return AVERROR_INVALIDDATA;

  645.             bytestream2_skip(&gbc, size);

  646.         }

  647.         end = bytestream2_tell(&gbc);

  648. 

  649.         err = ff_h2645_packet_split(&priv->read_packet,

  650.                                     frag->data + start, end - start,

  651.                                     ctx->log_ctx, 1, 2, AV_CODEC_ID_H264, 1, 1);

  652.         if (err < 0) {

  653.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split AVCC SPS array.\n");

  654.             return err;

  655.         }

  656.         err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);

  657.         if (err < 0)

  658.             return err;

  659. 

  660.         // PPS array.

  661.         count = bytestream2_get_byte(&gbc);

  662.         start = bytestream2_tell(&gbc);

  663.         for (i = 0; i < count; i++) {

  664.             if (bytestream2_get_bytes_left(&gbc) < 2 * (count - i))

  665.                 return AVERROR_INVALIDDATA;

  666.             size = bytestream2_get_be16(&gbc);

  667.             if (bytestream2_get_bytes_left(&gbc) < size)

  668.                 return AVERROR_INVALIDDATA;

  669.             bytestream2_skip(&gbc, size);

  670.         }

  671.         end = bytestream2_tell(&gbc);

  672. 

  673.         err = ff_h2645_packet_split(&priv->read_packet,

  674.                                     frag->data + start, end - start,

  675.                                     ctx->log_ctx, 1, 2, AV_CODEC_ID_H264, 1, 1);

  676.         if (err < 0) {

  677.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split AVCC PPS array.\n");

  678.             return err;

  679.         }

  680.         err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);

  681.         if (err < 0)

  682.             return err;

  683. 

  684.         if (bytestream2_get_bytes_left(&gbc) > 0) {

  685.             av_log(ctx->log_ctx, AV_LOG_WARNING, "%u bytes left at end of AVCC "

  686.                    "header.\n", bytestream2_get_bytes_left(&gbc));

  687.         }

  688. 

  689.     } else if (header && frag->data[0] && codec_id == AV_CODEC_ID_HEVC) {

  690.         // HVCC header.

  691.         size_t size, start, end;

  692.         int i, j, nb_arrays, nal_unit_type, nb_nals, version;

  693. 

  694.         priv->mp4 = 1;

  695. 

  696.         bytestream2_init(&gbc, frag->data, frag->data_size);

  697. 

  698.         if (bytestream2_get_bytes_left(&gbc) < 23)

  699.             return AVERROR_INVALIDDATA;

  700. 

  701.         version = bytestream2_get_byte(&gbc);

  702.         if (version != 1) {

  703.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid HVCC header: "

  704.                    "first byte %u.\n", version);

  705.             return AVERROR_INVALIDDATA;

  706.         }

  707. 

  708.         bytestream2_skip(&gbc, 20);

  709.         priv->nal_length_size = (bytestream2_get_byte(&gbc) & 3) + 1;

  710. 

  711.         nb_arrays = bytestream2_get_byte(&gbc);

  712.         for (i = 0; i < nb_arrays; i++) {

  713.             nal_unit_type = bytestream2_get_byte(&gbc) & 0x3f;

  714.             nb_nals = bytestream2_get_be16(&gbc);

  715. 

  716.             start = bytestream2_tell(&gbc);

  717.             for (j = 0; j < nb_nals; j++) {

  718.                 if (bytestream2_get_bytes_left(&gbc) < 2)

  719.                     return AVERROR_INVALIDDATA;

  720.                 size = bytestream2_get_be16(&gbc);

  721.                 if (bytestream2_get_bytes_left(&gbc) < size)

  722.                     return AVERROR_INVALIDDATA;

  723.                 bytestream2_skip(&gbc, size);

  724.             }

  725.             end = bytestream2_tell(&gbc);

  726. 

  727.             err = ff_h2645_packet_split(&priv->read_packet,

  728.                                         frag->data + start, end - start,

  729.                                         ctx->log_ctx, 1, 2, AV_CODEC_ID_HEVC, 1, 1);

  730.             if (err < 0) {

  731.                 av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split "

  732.                        "HVCC array %d (%d NAL units of type %d).\n",

  733.                        i, nb_nals, nal_unit_type);

  734.                 return err;

  735.             }

  736.             err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);

  737.             if (err < 0)

  738.                 return err;

  739.         }

  740. 

  741.     } else {

  742.         // Annex B, or later MP4 with already-known parameters.

  743. 

  744.         err = ff_h2645_packet_split(&priv->read_packet,

  745.                                     frag->data, frag->data_size,

  746.                                     ctx->log_ctx,

  747.                                     priv->mp4, priv->nal_length_size,

  748.                                     codec_id, 1, 1);

  749.         if (err < 0)

  750.             return err;

  751. 

  752.         err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);

  753.         if (err < 0)

  754.             return err;

  755.     }

  756. 

  757.     return 0;

  758. }

  759. 

  760. #define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element) \

  761. static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \

  762.                                                   CodedBitstreamUnit *unit)  \

  763. { \

  764.     CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \

  765.     H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \

  766.     unsigned int id = ps_var->id_element; \

  767.     if (id >= FF_ARRAY_ELEMS(priv->ps_var)) { \

  768.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid " #ps_name \

  769.                " id : %d.\n", id); \

  770.         return AVERROR_INVALIDDATA; \

  771.     } \

  772.     if (priv->ps_var[id] == priv->active_ ## ps_var) \

  773.         priv->active_ ## ps_var = NULL ; \

  774.     av_buffer_unref(&priv->ps_var ## _ref[id]); \

  775.     if (unit->content_ref) \

  776.         priv->ps_var ## _ref[id] = av_buffer_ref(unit->content_ref); \

  777.     else \

  778.         priv->ps_var ## _ref[id] = av_buffer_alloc(sizeof(*ps_var)); \

  779.     if (!priv->ps_var ## _ref[id]) \

  780.         return AVERROR(ENOMEM); \

  781.     priv->ps_var[id] = (H26 ## h26n ## Raw ## ps_name *)priv->ps_var ## _ref[id]->data; \

  782.     if (!unit->content_ref) \

  783.         memcpy(priv->ps_var[id], ps_var, sizeof(*ps_var)); \

  784.     return 0; \

  785. }

  786. 

  787. cbs_h2645_replace_ps(4, SPS, sps, seq_parameter_set_id)

  788. cbs_h2645_replace_ps(4, PPS, pps, pic_parameter_set_id)

  789. cbs_h2645_replace_ps(5, VPS, vps, vps_video_parameter_set_id)

  790. cbs_h2645_replace_ps(5, SPS, sps, sps_seq_parameter_set_id)

  791. cbs_h2645_replace_ps(5, PPS, pps, pps_pic_parameter_set_id)

  792. 

  793. static int cbs_h264_read_nal_unit(CodedBitstreamContext *ctx,

  794.                                   CodedBitstreamUnit *unit)

  795. {

  796.     GetBitContext gbc;

  797.     int err;

  798. 

  799.     err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);

  800.     if (err < 0)

  801.         return err;

  802. 

  803.     switch (unit->type) {

  804.     case H264_NAL_SPS:

  805.         {

  806.             H264RawSPS *sps;

  807. 

  808.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*sps), NULL);

  809.             if (err < 0)

  810.                 return err;

  811.             sps = unit->content;

  812. 

  813.             err = cbs_h264_read_sps(ctx, &gbc, sps);

  814.             if (err < 0)

  815.                 return err;

  816. 

  817.             err = cbs_h264_replace_sps(ctx, unit);

  818.             if (err < 0)

  819.                 return err;

  820.         }

  821.         break;

  822. 

  823.     case H264_NAL_SPS_EXT:

  824.         {

  825.             err = ff_cbs_alloc_unit_content(ctx, unit,

  826.                                             sizeof(H264RawSPSExtension),

  827.                                             NULL);

  828.             if (err < 0)

  829.                 return err;

  830. 

  831.             err = cbs_h264_read_sps_extension(ctx, &gbc, unit->content);

  832.             if (err < 0)

  833.                 return err;

  834.         }

  835.         break;

  836. 

  837.     case H264_NAL_PPS:

  838.         {

  839.             H264RawPPS *pps;

  840. 

  841.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*pps),

  842.                                             &cbs_h264_free_pps);

  843.             if (err < 0)

  844.                 return err;

  845.             pps = unit->content;

  846. 

  847.             err = cbs_h264_read_pps(ctx, &gbc, pps);

  848.             if (err < 0)

  849.                 return err;

  850. 

  851.             err = cbs_h264_replace_pps(ctx, unit);

  852.             if (err < 0)

  853.                 return err;

  854.         }

  855.         break;

  856. 

  857.     case H264_NAL_SLICE:

  858.     case H264_NAL_IDR_SLICE:

  859.     case H264_NAL_AUXILIARY_SLICE:

  860.         {

  861.             H264RawSlice *slice;

  862.             int pos, len;

  863. 

  864.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*slice),

  865.                                             &cbs_h264_free_slice);

  866.             if (err < 0)

  867.                 return err;

  868.             slice = unit->content;

  869. 

  870.             err = cbs_h264_read_slice_header(ctx, &gbc, &slice->header);

  871.             if (err < 0)

  872.                 return err;

  873. 

  874.             if (!cbs_h2645_read_more_rbsp_data(&gbc))

  875.                 return AVERROR_INVALIDDATA;

  876. 

  877.             pos = get_bits_count(&gbc);

  878.             len = unit->data_size;

  879. 

  880.             slice->data_size = len - pos / 8;

  881.             slice->data_ref  = av_buffer_ref(unit->data_ref);

  882.             if (!slice->data_ref)

  883.                 return AVERROR(ENOMEM);

  884.             slice->data = unit->data + pos / 8;

  885.             slice->data_bit_start = pos % 8;

  886.         }

  887.         break;

  888. 

  889.     case H264_NAL_AUD:

  890.         {

  891.             err = ff_cbs_alloc_unit_content(ctx, unit,

  892.                                             sizeof(H264RawAUD), NULL);

  893.             if (err < 0)

  894.                 return err;

  895. 

  896.             err = cbs_h264_read_aud(ctx, &gbc, unit->content);

  897.             if (err < 0)

  898.                 return err;

  899.         }

  900.         break;

  901. 

  902.     case H264_NAL_SEI:

  903.         {

  904.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(H264RawSEI),

  905.                                             &cbs_h264_free_sei);

  906.             if (err < 0)

  907.                 return err;

  908. 

  909.             err = cbs_h264_read_sei(ctx, &gbc, unit->content);

  910.             if (err < 0)

  911.                 return err;

  912.         }

  913.         break;

  914. 

  915.     case H264_NAL_FILLER_DATA:

  916.         {

  917.             err = ff_cbs_alloc_unit_content(ctx, unit,

  918.                                             sizeof(H264RawFiller), NULL);

  919.             if (err < 0)

  920.                 return err;

  921. 

  922.             err = cbs_h264_read_filler(ctx, &gbc, unit->content);

  923.             if (err < 0)

  924.                 return err;

  925.         }

  926.         break;

  927. 

  928.     case H264_NAL_END_SEQUENCE:

  929.     case H264_NAL_END_STREAM:

  930.         {

  931.             err = ff_cbs_alloc_unit_content(ctx, unit,

  932.                                             sizeof(H264RawNALUnitHeader),

  933.                                             NULL);

  934.             if (err < 0)

  935.                 return err;

  936. 

  937.             err = (unit->type == H264_NAL_END_SEQUENCE ?

  938.                    cbs_h264_read_end_of_sequence :

  939.                    cbs_h264_read_end_of_stream)(ctx, &gbc, unit->content);

  940.             if (err < 0)

  941.                 return err;

  942.         }

  943.         break;

  944. 

  945.     default:

  946.         return AVERROR(ENOSYS);

  947.     }

  948. 

  949.     return 0;

  950. }

  951. 

  952. static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,

  953.                                   CodedBitstreamUnit *unit)

  954. {

  955.     GetBitContext gbc;

  956.     int err;

  957. 

  958.     err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);

  959.     if (err < 0)

  960.         return err;

  961. 

  962.     switch (unit->type) {

  963.     case HEVC_NAL_VPS:

  964.         {

  965.             H265RawVPS *vps;

  966. 

  967.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*vps),

  968.                                             &cbs_h265_free_vps);

  969.             if (err < 0)

  970.                 return err;

  971.             vps = unit->content;

  972. 

  973.             err = cbs_h265_read_vps(ctx, &gbc, vps);

  974.             if (err < 0)

  975.                 return err;

  976. 

  977.             err = cbs_h265_replace_vps(ctx, unit);

  978.             if (err < 0)

  979.                 return err;

  980.         }

  981.         break;

  982.     case HEVC_NAL_SPS:

  983.         {

  984.             H265RawSPS *sps;

  985. 

  986.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*sps),

  987.                                             &cbs_h265_free_sps);

  988.             if (err < 0)

  989.                 return err;

  990.             sps = unit->content;

  991. 

  992.             err = cbs_h265_read_sps(ctx, &gbc, sps);

  993.             if (err < 0)

  994.                 return err;

  995. 

  996.             err = cbs_h265_replace_sps(ctx, unit);

  997.             if (err < 0)

  998.                 return err;

  999.         }

  1000.         break;

  1001. 

  1002.     case HEVC_NAL_PPS:

  1003.         {

  1004.             H265RawPPS *pps;

  1005. 

  1006.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*pps),

  1007.                                             &cbs_h265_free_pps);

  1008.             if (err < 0)

  1009.                 return err;

  1010.             pps = unit->content;

  1011. 

  1012.             err = cbs_h265_read_pps(ctx, &gbc, pps);

  1013.             if (err < 0)

  1014.                 return err;

  1015. 

  1016.             err = cbs_h265_replace_pps(ctx, unit);

  1017.             if (err < 0)

  1018.                 return err;

  1019.         }

  1020.         break;

  1021. 

  1022.     case HEVC_NAL_TRAIL_N:

  1023.     case HEVC_NAL_TRAIL_R:

  1024.     case HEVC_NAL_TSA_N:

  1025.     case HEVC_NAL_TSA_R:

  1026.     case HEVC_NAL_STSA_N:

  1027.     case HEVC_NAL_STSA_R:

  1028.     case HEVC_NAL_RADL_N:

  1029.     case HEVC_NAL_RADL_R:

  1030.     case HEVC_NAL_RASL_N:

  1031.     case HEVC_NAL_RASL_R:

  1032.     case HEVC_NAL_BLA_W_LP:

  1033.     case HEVC_NAL_BLA_W_RADL:

  1034.     case HEVC_NAL_BLA_N_LP:

  1035.     case HEVC_NAL_IDR_W_RADL:

  1036.     case HEVC_NAL_IDR_N_LP:

  1037.     case HEVC_NAL_CRA_NUT:

  1038.         {

  1039.             H265RawSlice *slice;

  1040.             int pos, len;

  1041. 

  1042.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*slice),

  1043.                                             &cbs_h265_free_slice);

  1044.             if (err < 0)

  1045.                 return err;

  1046.             slice = unit->content;

  1047. 

  1048.             err = cbs_h265_read_slice_segment_header(ctx, &gbc, &slice->header);

  1049.             if (err < 0)

  1050.                 return err;

  1051. 

  1052.             if (!cbs_h2645_read_more_rbsp_data(&gbc))

  1053.                 return AVERROR_INVALIDDATA;

  1054. 

  1055.             pos = get_bits_count(&gbc);

  1056.             len = unit->data_size;

  1057. 

  1058.             slice->data_size = len - pos / 8;

  1059.             slice->data_ref  = av_buffer_ref(unit->data_ref);

  1060.             if (!slice->data_ref)

  1061.                 return AVERROR(ENOMEM);

  1062.             slice->data = unit->data + pos / 8;

  1063.             slice->data_bit_start = pos % 8;

  1064.         }

  1065.         break;

  1066. 

  1067.     case HEVC_NAL_AUD:

  1068.         {

  1069.             err = ff_cbs_alloc_unit_content(ctx, unit,

  1070.                                             sizeof(H265RawAUD), NULL);

  1071.             if (err < 0)

  1072.                 return err;

  1073. 

  1074.             err = cbs_h265_read_aud(ctx, &gbc, unit->content);

  1075.             if (err < 0)

  1076.                 return err;

  1077.         }

  1078.         break;

  1079. 

  1080.     case HEVC_NAL_SEI_PREFIX:

  1081.     case HEVC_NAL_SEI_SUFFIX:

  1082.         {

  1083.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(H265RawSEI),

  1084.                                             &cbs_h265_free_sei);

  1085. 

  1086.             if (err < 0)

  1087.                 return err;

  1088. 

  1089.             err = cbs_h265_read_sei(ctx, &gbc, unit->content,

  1090.                                     unit->type == HEVC_NAL_SEI_PREFIX);

  1091. 

  1092.             if (err < 0)

  1093.                 return err;

  1094.         }

  1095.         break;

  1096. 

  1097.     default:

  1098.         return AVERROR(ENOSYS);

  1099.     }

  1100. 

  1101.     return 0;

  1102. }

  1103. 

  1104. static int cbs_h2645_write_slice_data(CodedBitstreamContext *ctx,

  1105.                                       PutBitContext *pbc, const uint8_t *data,

  1106.                                       size_t data_size, int data_bit_start)

  1107. {

  1108.     size_t rest  = data_size - (data_bit_start + 7) / 8;

  1109.     const uint8_t *pos = data + data_bit_start / 8;

  1110. 

  1111.     av_assert0(data_bit_start >= 0 &&

  1112.                data_size > data_bit_start / 8);

  1113. 

  1114.     if (data_size * 8 + 8 > put_bits_left(pbc))

  1115.         return AVERROR(ENOSPC);

  1116. 

  1117.     if (!rest)

  1118.         goto rbsp_stop_one_bit;

  1119. 

  1120.     // First copy the remaining bits of the first byte

  1121.     // The above check ensures that we do not accidentally

  1122.     // copy beyond the rbsp_stop_one_bit.

  1123.     if (data_bit_start % 8)

  1124.         put_bits(pbc, 8 - data_bit_start % 8,

  1125.                  *pos++ & MAX_UINT_BITS(8 - data_bit_start % 8));

  1126. 

  1127.     if (put_bits_count(pbc) % 8 == 0) {

  1128.         // If the writer is aligned at this point,

  1129.         // memcpy can be used to improve performance.

  1130.         // This happens normally for CABAC.

  1131.         flush_put_bits(pbc);

  1132.         memcpy(put_bits_ptr(pbc), pos, rest);

  1133.         skip_put_bytes(pbc, rest);

  1134.     } else {

  1135.         // If not, we have to copy manually.

  1136.         // rbsp_stop_one_bit forces us to special-case

  1137.         // the last byte.

  1138.         uint8_t temp;

  1139.         int i;

  1140. 

  1141.         for (; rest > 4; rest -= 4, pos += 4)

  1142.             put_bits32(pbc, AV_RB32(pos));

  1143. 

  1144.         for (; rest > 1; rest--, pos++)

  1145.             put_bits(pbc, 8, *pos);

  1146. 

  1147.     rbsp_stop_one_bit:

  1148.         temp = rest ? *pos : *pos & MAX_UINT_BITS(8 - data_bit_start % 8);

  1149. 

  1150.         av_assert0(temp);

  1151.         i = ff_ctz(*pos);

  1152.         temp = temp >> i;

  1153.         i = rest ? (8 - i) : (8 - i - data_bit_start % 8);

  1154.         put_bits(pbc, i, temp);

  1155.         if (put_bits_count(pbc) % 8)

  1156.             put_bits(pbc, 8 - put_bits_count(pbc) % 8, 0);

  1157.     }

  1158. 

  1159.     return 0;

  1160. }

  1161. 

  1162. static int cbs_h264_write_nal_unit(CodedBitstreamContext *ctx,

  1163.                                    CodedBitstreamUnit *unit,

  1164.                                    PutBitContext *pbc)

  1165. {

  1166.     int err;

  1167. 

  1168.     switch (unit->type) {

  1169.     case H264_NAL_SPS:

  1170.         {

  1171.             H264RawSPS *sps = unit->content;

  1172. 

  1173.             err = cbs_h264_write_sps(ctx, pbc, sps);

  1174.             if (err < 0)

  1175.                 return err;

  1176. 

  1177.             err = cbs_h264_replace_sps(ctx, unit);

  1178.             if (err < 0)

  1179.                 return err;

  1180.         }

  1181.         break;

  1182. 

  1183.     case H264_NAL_SPS_EXT:

  1184.         {

  1185.             H264RawSPSExtension *sps_ext = unit->content;

  1186. 

  1187.             err = cbs_h264_write_sps_extension(ctx, pbc, sps_ext);

  1188.             if (err < 0)

  1189.                 return err;

  1190.         }

  1191.         break;

  1192. 

  1193.     case H264_NAL_PPS:

  1194.         {

  1195.             H264RawPPS *pps = unit->content;

  1196. 

  1197.             err = cbs_h264_write_pps(ctx, pbc, pps);

  1198.             if (err < 0)

  1199.                 return err;

  1200. 

  1201.             err = cbs_h264_replace_pps(ctx, unit);

  1202.             if (err < 0)

  1203.                 return err;

  1204.         }

  1205.         break;

  1206. 

  1207.     case H264_NAL_SLICE:

  1208.     case H264_NAL_IDR_SLICE:

  1209.     case H264_NAL_AUXILIARY_SLICE:

  1210.         {

  1211.             H264RawSlice *slice = unit->content;

  1212. 

  1213.             err = cbs_h264_write_slice_header(ctx, pbc, &slice->header);

  1214.             if (err < 0)

  1215.                 return err;

  1216. 

  1217.             if (slice->data) {

  1218.                 err = cbs_h2645_write_slice_data(ctx, pbc, slice->data,

  1219.                                                  slice->data_size,

  1220.                                                  slice->data_bit_start);

  1221.                 if (err < 0)

  1222.                     return err;

  1223.             } else {

  1224.                 // No slice data - that was just the header.

  1225.                 // (Bitstream may be unaligned!)

  1226.             }

  1227.         }

  1228.         break;

  1229. 

  1230.     case H264_NAL_AUD:

  1231.         {

  1232.             err = cbs_h264_write_aud(ctx, pbc, unit->content);

  1233.             if (err < 0)

  1234.                 return err;

  1235.         }

  1236.         break;

  1237. 

  1238.     case H264_NAL_SEI:

  1239.         {

  1240.             err = cbs_h264_write_sei(ctx, pbc, unit->content);

  1241.             if (err < 0)

  1242.                 return err;

  1243.         }

  1244.         break;

  1245. 

  1246.     case H264_NAL_FILLER_DATA:

  1247.         {

  1248.             err = cbs_h264_write_filler(ctx, pbc, unit->content);

  1249.             if (err < 0)

  1250.                 return err;

  1251.         }

  1252.         break;

  1253. 

  1254.     case H264_NAL_END_SEQUENCE:

  1255.         {

  1256.             err = cbs_h264_write_end_of_sequence(ctx, pbc, unit->content);

  1257.             if (err < 0)

  1258.                 return err;

  1259.         }

  1260.         break;

  1261. 

  1262.     case H264_NAL_END_STREAM:

  1263.         {

  1264.             err = cbs_h264_write_end_of_stream(ctx, pbc, unit->content);

  1265.             if (err < 0)

  1266.                 return err;

  1267.         }

  1268.         break;

  1269. 

  1270.     default:

  1271.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for "

  1272.                "NAL unit type %"PRIu32".\n", unit->type);

  1273.         return AVERROR_PATCHWELCOME;

  1274.     }

  1275. 

  1276.     return 0;

  1277. }

  1278. 

  1279. static int cbs_h265_write_nal_unit(CodedBitstreamContext *ctx,

  1280.                                    CodedBitstreamUnit *unit,

  1281.                                    PutBitContext *pbc)

  1282. {

  1283.     int err;

  1284. 

  1285.     switch (unit->type) {

  1286.     case HEVC_NAL_VPS:

  1287.         {

  1288.             H265RawVPS *vps = unit->content;

  1289. 

  1290.             err = cbs_h265_write_vps(ctx, pbc, vps);

  1291.             if (err < 0)

  1292.                 return err;

  1293. 

  1294.             err = cbs_h265_replace_vps(ctx, unit);

  1295.             if (err < 0)

  1296.                 return err;

  1297.         }

  1298.         break;

  1299. 

  1300.     case HEVC_NAL_SPS:

  1301.         {

  1302.             H265RawSPS *sps = unit->content;

  1303. 

  1304.             err = cbs_h265_write_sps(ctx, pbc, sps);

  1305.             if (err < 0)

  1306.                 return err;

  1307. 

  1308.             err = cbs_h265_replace_sps(ctx, unit);

  1309.             if (err < 0)

  1310.                 return err;

  1311.         }

  1312.         break;

  1313. 

  1314.     case HEVC_NAL_PPS:

  1315.         {

  1316.             H265RawPPS *pps = unit->content;

  1317. 

  1318.             err = cbs_h265_write_pps(ctx, pbc, pps);

  1319.             if (err < 0)

  1320.                 return err;

  1321. 

  1322.             err = cbs_h265_replace_pps(ctx, unit);

  1323.             if (err < 0)

  1324.                 return err;

  1325.         }

  1326.         break;

  1327. 

  1328.     case HEVC_NAL_TRAIL_N:

  1329.     case HEVC_NAL_TRAIL_R:

  1330.     case HEVC_NAL_TSA_N:

  1331.     case HEVC_NAL_TSA_R:

  1332.     case HEVC_NAL_STSA_N:

  1333.     case HEVC_NAL_STSA_R:

  1334.     case HEVC_NAL_RADL_N:

  1335.     case HEVC_NAL_RADL_R:

  1336.     case HEVC_NAL_RASL_N:

  1337.     case HEVC_NAL_RASL_R:

  1338.     case HEVC_NAL_BLA_W_LP:

  1339.     case HEVC_NAL_BLA_W_RADL:

  1340.     case HEVC_NAL_BLA_N_LP:

  1341.     case HEVC_NAL_IDR_W_RADL:

  1342.     case HEVC_NAL_IDR_N_LP:

  1343.     case HEVC_NAL_CRA_NUT:

  1344.         {

  1345.             H265RawSlice *slice = unit->content;

  1346. 

  1347.             err = cbs_h265_write_slice_segment_header(ctx, pbc, &slice->header);

  1348.             if (err < 0)

  1349.                 return err;

  1350. 

  1351.             if (slice->data) {

  1352.                 err = cbs_h2645_write_slice_data(ctx, pbc, slice->data,

  1353.                                                  slice->data_size,

  1354.                                                  slice->data_bit_start);

  1355.                 if (err < 0)

  1356.                     return err;

  1357.             } else {

  1358.                 // No slice data - that was just the header.

  1359.             }

  1360.         }

  1361.         break;

  1362. 

  1363.     case HEVC_NAL_AUD:

  1364.         {

  1365.             err = cbs_h265_write_aud(ctx, pbc, unit->content);

  1366.             if (err < 0)

  1367.                 return err;

  1368.         }

  1369.         break;

  1370. 

  1371.     case HEVC_NAL_SEI_PREFIX:

  1372.     case HEVC_NAL_SEI_SUFFIX:

  1373.         {

  1374.             err = cbs_h265_write_sei(ctx, pbc, unit->content,

  1375.                                      unit->type == HEVC_NAL_SEI_PREFIX);

  1376. 

  1377.             if (err < 0)

  1378.                 return err;

  1379.         }

  1380.         break;

  1381. 

  1382.     default:

  1383.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for "

  1384.                "NAL unit type %"PRIu32".\n", unit->type);

  1385.         return AVERROR_PATCHWELCOME;

  1386.     }

  1387. 

  1388.     return 0;

  1389. }

  1390. 

  1391. static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,

  1392.                                        CodedBitstreamFragment *frag)

  1393. {

  1394.     uint8_t *data;

  1395.     size_t max_size, dp, sp;

  1396.     int err, i, zero_run;

  1397. 

  1398.     for (i = 0; i < frag->nb_units; i++) {

  1399.         // Data should already all have been written when we get here.

  1400.         av_assert0(frag->units[i].data);

  1401.     }

  1402. 

  1403.     max_size = 0;

  1404.     for (i = 0; i < frag->nb_units; i++) {

  1405.         // Start code + content with worst-case emulation prevention.

  1406.         max_size += 4 + frag->units[i].data_size * 3 / 2;

  1407.     }

  1408. 

  1409.     data = av_realloc(NULL, max_size + AV_INPUT_BUFFER_PADDING_SIZE);

  1410.     if (!data)

  1411.         return AVERROR(ENOMEM);

  1412. 

  1413.     dp = 0;

  1414.     for (i = 0; i < frag->nb_units; i++) {

  1415.         CodedBitstreamUnit *unit = &frag->units[i];

  1416. 

  1417.         if (unit->data_bit_padding > 0) {

  1418.             if (i < frag->nb_units - 1)

  1419.                 av_log(ctx->log_ctx, AV_LOG_WARNING, "Probably invalid "

  1420.                        "unaligned padding on non-final NAL unit.\n");

  1421.             else

  1422.                 frag->data_bit_padding = unit->data_bit_padding;

  1423.         }

  1424. 

  1425.         if ((ctx->codec->codec_id == AV_CODEC_ID_H264 &&

  1426.              (unit->type == H264_NAL_SPS ||

  1427.               unit->type == H264_NAL_PPS)) ||

  1428.             (ctx->codec->codec_id == AV_CODEC_ID_HEVC &&

  1429.              (unit->type == HEVC_NAL_VPS ||

  1430.               unit->type == HEVC_NAL_SPS ||

  1431.               unit->type == HEVC_NAL_PPS)) ||

  1432.             i == 0 /* (Assume this is the start of an access unit.) */) {

  1433.             // zero_byte

  1434.             data[dp++] = 0;

  1435.         }

  1436.         // start_code_prefix_one_3bytes

  1437.         data[dp++] = 0;

  1438.         data[dp++] = 0;

  1439.         data[dp++] = 1;

  1440. 

  1441.         zero_run = 0;

  1442.         for (sp = 0; sp < unit->data_size; sp++) {

  1443.             if (zero_run < 2) {

  1444.                 if (unit->data[sp] == 0)

  1445.                     ++zero_run;

  1446.                 else

  1447.                     zero_run = 0;

  1448.             } else {

  1449.                 if ((unit->data[sp] & ~3) == 0) {

  1450.                     // emulation_prevention_three_byte

  1451.                     data[dp++] = 3;

  1452.                 }

  1453.                 zero_run = unit->data[sp] == 0;

  1454.             }

  1455.             data[dp++] = unit->data[sp];

  1456.         }

  1457.     }

  1458. 

  1459.     av_assert0(dp <= max_size);

  1460.     err = av_reallocp(&data, dp + AV_INPUT_BUFFER_PADDING_SIZE);

  1461.     if (err)

  1462.         return err;

  1463.     memset(data + dp, 0, AV_INPUT_BUFFER_PADDING_SIZE);

  1464. 

  1465.     frag->data_ref = av_buffer_create(data, dp + AV_INPUT_BUFFER_PADDING_SIZE,

  1466.                                       NULL, NULL, 0);

  1467.     if (!frag->data_ref) {

  1468.         av_freep(&data);

  1469.         return AVERROR(ENOMEM);

  1470.     }

  1471. 

  1472.     frag->data = data;

  1473.     frag->data_size = dp;

  1474. 

  1475.     return 0;

  1476. }

  1477. 

  1478. static void cbs_h264_close(CodedBitstreamContext *ctx)

  1479. {

  1480.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  1481.     int i;

  1482. 

  1483.     ff_h2645_packet_uninit(&h264->common.read_packet);

  1484. 

  1485.     for (i = 0; i < FF_ARRAY_ELEMS(h264->sps); i++)

  1486.         av_buffer_unref(&h264->sps_ref[i]);

  1487.     for (i = 0; i < FF_ARRAY_ELEMS(h264->pps); i++)

  1488.         av_buffer_unref(&h264->pps_ref[i]);

  1489. }

  1490. 

  1491. static void cbs_h265_close(CodedBitstreamContext *ctx)

  1492. {

  1493.     CodedBitstreamH265Context *h265 = ctx->priv_data;

  1494.     int i;

  1495. 

  1496.     ff_h2645_packet_uninit(&h265->common.read_packet);

  1497. 

  1498.     for (i = 0; i < FF_ARRAY_ELEMS(h265->vps); i++)

  1499.         av_buffer_unref(&h265->vps_ref[i]);

  1500.     for (i = 0; i < FF_ARRAY_ELEMS(h265->sps); i++)

  1501.         av_buffer_unref(&h265->sps_ref[i]);

  1502.     for (i = 0; i < FF_ARRAY_ELEMS(h265->pps); i++)

  1503.         av_buffer_unref(&h265->pps_ref[i]);

  1504. }

  1505. 

  1506. const CodedBitstreamType ff_cbs_type_h264 = {

  1507.     .codec_id          = AV_CODEC_ID_H264,

  1508. 

  1509.     .priv_data_size    = sizeof(CodedBitstreamH264Context),

  1510. 

  1511.     .split_fragment    = &cbs_h2645_split_fragment,

  1512.     .read_unit         = &cbs_h264_read_nal_unit,

  1513.     .write_unit        = &cbs_h264_write_nal_unit,

  1514.     .assemble_fragment = &cbs_h2645_assemble_fragment,

  1515. 

  1516.     .close             = &cbs_h264_close,

  1517. };

  1518. 

  1519. const CodedBitstreamType ff_cbs_type_h265 = {

  1520.     .codec_id          = AV_CODEC_ID_HEVC,

  1521. 

  1522.     .priv_data_size    = sizeof(CodedBitstreamH265Context),

  1523. 

  1524.     .split_fragment    = &cbs_h2645_split_fragment,

  1525.     .read_unit         = &cbs_h265_read_nal_unit,

  1526.     .write_unit        = &cbs_h265_write_nal_unit,

  1527.     .assemble_fragment = &cbs_h2645_assemble_fragment,

  1528. 

  1529.     .close             = &cbs_h265_close,

  1530. };

  1531. 

  1532. int ff_cbs_h264_add_sei_message(CodedBitstreamContext *ctx,

  1533.                                 CodedBitstreamFragment *au,

  1534.                                 H264RawSEIPayload *payload)

  1535. {

  1536.     H264RawSEI *sei = NULL;

  1537.     int err, i;

  1538. 

  1539.     // Find an existing SEI NAL unit to add to.

  1540.     for (i = 0; i < au->nb_units; i++) {

  1541.         if (au->units[i].type == H264_NAL_SEI) {

  1542.             sei = au->units[i].content;

  1543.             if (sei->payload_count < H264_MAX_SEI_PAYLOADS)

  1544.                 break;

  1545. 

  1546.             sei = NULL;

  1547.         }

  1548.     }

  1549. 

  1550.     if (!sei) {

  1551.         // Need to make a new SEI NAL unit.  Insert it before the first

  1552.         // slice data NAL unit; if no slice data, add at the end.

  1553.         AVBufferRef *sei_ref;

  1554. 

  1555.         sei = av_mallocz(sizeof(*sei));

  1556.         if (!sei) {

  1557.             err = AVERROR(ENOMEM);

  1558.             goto fail;

  1559.         }

  1560. 

  1561.         sei->nal_unit_header.nal_unit_type = H264_NAL_SEI;

  1562.         sei->nal_unit_header.nal_ref_idc   = 0;

  1563. 

  1564.         sei_ref = av_buffer_create((uint8_t*)sei, sizeof(*sei),

  1565.                                    &cbs_h264_free_sei, NULL, 0);

  1566.         if (!sei_ref) {

  1567.             av_freep(&sei);

  1568.             err = AVERROR(ENOMEM);

  1569.             goto fail;

  1570.         }

  1571. 

  1572.         for (i = 0; i < au->nb_units; i++) {

  1573.             if (au->units[i].type == H264_NAL_SLICE ||

  1574.                 au->units[i].type == H264_NAL_IDR_SLICE)

  1575.                 break;

  1576.         }

  1577. 

  1578.         err = ff_cbs_insert_unit_content(ctx, au, i, H264_NAL_SEI,

  1579.                                          sei, sei_ref);

  1580.         av_buffer_unref(&sei_ref);

  1581.         if (err < 0)

  1582.             goto fail;

  1583.     }

  1584. 

  1585.     memcpy(&sei->payload[sei->payload_count], payload, sizeof(*payload));

  1586.     ++sei->payload_count;

  1587. 

  1588.     return 0;

  1589. fail:

  1590.     cbs_h264_free_sei_payload(payload);

  1591.     return err;

  1592. }

  1593. 

  1594. void ff_cbs_h264_delete_sei_message(CodedBitstreamContext *ctx,

  1595.                                     CodedBitstreamFragment *au,

  1596.                                     CodedBitstreamUnit *nal,

  1597.                                     int position)

  1598. {

  1599.     H264RawSEI *sei = nal->content;

  1600. 

  1601.     av_assert0(nal->type == H264_NAL_SEI);

  1602.     av_assert0(position >= 0 && position < sei->payload_count);

  1603. 

  1604.     if (position == 0 && sei->payload_count == 1) {

  1605.         // Deleting NAL unit entirely.

  1606.         int i;

  1607. 

  1608.         for (i = 0; i < au->nb_units; i++) {

  1609.             if (&au->units[i] == nal)

  1610.                 break;

  1611.         }

  1612. 

  1613.         ff_cbs_delete_unit(ctx, au, i);

  1614.     } else {

  1615.         cbs_h264_free_sei_payload(&sei->payload[position]);

  1616. 

  1617.         --sei->payload_count;

  1618.         memmove(sei->payload + position,

  1619.                 sei->payload + position + 1,

  1620.                 (sei->payload_count - position) * sizeof(*sei->payload));

  1621.     }

  1622. }