bare-ffmpeg 1.0.0-1 → 1.0.0-10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/binding.c DELETED
@@ -1,1819 +0,0 @@
1
- #include <assert.h>
2
- #include <bare.h>
3
- #include <js.h>
4
- #include <libavcodec/avcodec.h>
5
- #include <libavcodec/codec.h>
6
- #include <libavcodec/codec_id.h>
7
- #include <libavcodec/codec_par.h>
8
- #include <libavcodec/packet.h>
9
- #include <libavdevice/avdevice.h>
10
- #include <libavformat/avformat.h>
11
- #include <libavformat/avio.h>
12
- #include <libavutil/dict.h>
13
- #include <libavutil/error.h>
14
- #include <libavutil/frame.h>
15
- #include <libavutil/imgutils.h>
16
- #include <libavutil/log.h>
17
- #include <libavutil/mem.h>
18
- #include <libavutil/pixfmt.h>
19
- #include <libavutil/rational.h>
20
- #include <libswscale/swscale.h>
21
- #include <stddef.h>
22
- #include <stdint.h>
23
- #include <string.h>
24
-
25
- typedef struct {
26
- AVIOContext *handle;
27
- } bare_ffmpeg_io_context_t;
28
-
29
- typedef struct {
30
- const AVOutputFormat *handle;
31
- } bare_ffmpeg_output_format_t;
32
-
33
- typedef struct {
34
- const AVInputFormat *handle;
35
- } bare_ffmpeg_input_format_t;
36
-
37
- typedef struct {
38
- AVFormatContext *handle;
39
- } bare_ffmpeg_format_context_t;
40
-
41
- typedef struct {
42
- AVStream *handle;
43
- } bare_ffmpeg_stream_t;
44
-
45
- typedef struct {
46
- const AVCodec *handle;
47
- } bare_ffmpeg_codec_t;
48
-
49
- typedef struct {
50
- AVCodecParameters *handle;
51
- } bare_ffmpeg_codec_parameters_t;
52
-
53
- typedef struct {
54
- AVCodecContext *handle;
55
- } bare_ffmpeg_codec_context_t;
56
-
57
- typedef struct {
58
- AVFrame *handle;
59
- } bare_ffmpeg_frame_t;
60
-
61
- typedef struct {
62
- AVPacket handle;
63
- } bare_ffmpeg_packet_t;
64
-
65
- typedef struct {
66
- struct SwsContext *handle;
67
- } bare_ffmpeg_scaler_t;
68
-
69
- typedef struct {
70
- struct AVDictionary *handle;
71
- } bare_ffmpeg_dictionary_t;
72
-
73
- static uv_once_t bare_ffmpeg__init_guard = UV_ONCE_INIT;
74
-
75
- static void
76
- bare_ffmpeg__on_init(void) {
77
- av_log_set_level(AV_LOG_ERROR);
78
- avdevice_register_all();
79
- }
80
-
81
- static js_value_t *
82
- bare_ffmpeg_io_context_init(js_env_t *env, js_callback_info_t *info) {
83
- int err;
84
-
85
- size_t argc = 1;
86
- js_value_t *argv[1];
87
-
88
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
89
- assert(err == 0);
90
-
91
- assert(argc == 1);
92
-
93
- void *data;
94
- size_t len;
95
- err = js_get_typedarray_info(env, argv[0], NULL, &data, &len, NULL, NULL);
96
- assert(err == 0);
97
-
98
- js_value_t *handle;
99
-
100
- bare_ffmpeg_io_context_t *context;
101
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_io_context_t), (void **) &context, &handle);
102
- assert(err == 0);
103
-
104
- uint8_t *io;
105
-
106
- if (len == 0) io = NULL;
107
- else {
108
- io = av_malloc(len);
109
-
110
- memcpy(io, data, len);
111
- }
112
-
113
- context->handle = avio_alloc_context(io, len, 0, NULL, NULL, NULL, NULL);
114
-
115
- context->handle->opaque = (void *) context;
116
-
117
- return handle;
118
- }
119
-
120
- static js_value_t *
121
- bare_ffmpeg_io_context_destroy(js_env_t *env, js_callback_info_t *info) {
122
- int err;
123
-
124
- size_t argc = 1;
125
- js_value_t *argv[1];
126
-
127
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
128
- assert(err == 0);
129
-
130
- assert(argc == 1);
131
-
132
- bare_ffmpeg_io_context_t *context;
133
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
134
- assert(err == 0);
135
-
136
- av_free(context->handle->buffer);
137
-
138
- avio_context_free(&context->handle);
139
-
140
- return NULL;
141
- }
142
-
143
- static js_value_t *
144
- bare_ffmpeg_output_format_init(js_env_t *env, js_callback_info_t *info) {
145
- int err;
146
-
147
- size_t argc = 1;
148
- js_value_t *argv[1];
149
-
150
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
151
- assert(err == 0);
152
-
153
- assert(argc == 1);
154
-
155
- size_t len;
156
- err = js_get_value_string_utf8(env, argv[0], NULL, 0, &len);
157
- assert(err == 0);
158
-
159
- len += +1 /* NULL */;
160
-
161
- utf8_t *name = malloc(len);
162
- err = js_get_value_string_utf8(env, argv[0], name, len, NULL);
163
- assert(err == 0);
164
-
165
- const AVOutputFormat *format = av_guess_format((const char *) name, NULL, NULL);
166
-
167
- if (format == NULL) {
168
- err = js_throw_errorf(env, NULL, "No output format found for name '%s'", name);
169
- assert(err == 0);
170
- free(name);
171
-
172
- return NULL;
173
- }
174
- free(name);
175
-
176
- js_value_t *handle;
177
-
178
- bare_ffmpeg_output_format_t *context;
179
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_output_format_t), (void **) &context, &handle);
180
- assert(err == 0);
181
-
182
- context->handle = format;
183
-
184
- return handle;
185
- }
186
-
187
- static js_value_t *
188
- bare_ffmpeg_input_format_init(js_env_t *env, js_callback_info_t *info) {
189
- int err;
190
-
191
- size_t argc = 1;
192
- js_value_t *argv[1];
193
-
194
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
195
- assert(err == 0);
196
-
197
- assert(argc == 1);
198
-
199
- size_t len;
200
- err = js_get_value_string_utf8(env, argv[0], NULL, 0, &len);
201
- assert(err == 0);
202
-
203
- len += +1 /* NULL */;
204
-
205
- utf8_t *name = malloc(len);
206
- err = js_get_value_string_utf8(env, argv[0], name, len, NULL);
207
- assert(err == 0);
208
-
209
- const AVInputFormat *format = av_find_input_format((const char *) name);
210
-
211
- if (format == NULL) {
212
- err = js_throw_errorf(env, NULL, "No input format found for name '%s'", name);
213
- assert(err == 0);
214
- free(name);
215
-
216
- return NULL;
217
- }
218
- free(name);
219
-
220
- js_value_t *handle;
221
-
222
- bare_ffmpeg_input_format_t *context;
223
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_input_format_t), (void **) &context, &handle);
224
- assert(err == 0);
225
-
226
- context->handle = format;
227
-
228
- return handle;
229
- }
230
-
231
- static js_value_t *
232
- bare_ffmpeg_format_context_open_input(js_env_t *env, js_callback_info_t *info) {
233
- int err;
234
-
235
- size_t argc = 1;
236
- js_value_t *argv[1];
237
-
238
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
239
- assert(err == 0);
240
-
241
- assert(argc == 1);
242
-
243
- bare_ffmpeg_io_context_t *io;
244
- err = js_get_arraybuffer_info(env, argv[0], (void **) &io, NULL);
245
- assert(err == 0);
246
-
247
- js_value_t *handle;
248
-
249
- bare_ffmpeg_format_context_t *context;
250
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_format_context_t), (void **) &context, &handle);
251
- assert(err == 0);
252
-
253
- context->handle = avformat_alloc_context();
254
-
255
- context->handle->pb = io->handle;
256
- context->handle->opaque = (void *) context;
257
-
258
- err = avformat_open_input(&context->handle, NULL, NULL, NULL);
259
-
260
- if (err < 0) {
261
- avformat_free_context(context->handle);
262
-
263
- err = js_throw_error(env, NULL, av_err2str(err));
264
- assert(err == 0);
265
-
266
- return NULL;
267
- }
268
-
269
- err = avformat_find_stream_info(context->handle, NULL);
270
-
271
- if (err < 0) {
272
- avformat_close_input(&context->handle);
273
-
274
- err = js_throw_error(env, NULL, av_err2str(err));
275
- assert(err == 0);
276
-
277
- return NULL;
278
- }
279
-
280
- return handle;
281
- }
282
-
283
- static js_value_t *
284
- bare_ffmpeg_format_context_close_input(js_env_t *env, js_callback_info_t *info) {
285
- int err;
286
-
287
- size_t argc = 1;
288
- js_value_t *argv[1];
289
-
290
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
291
- assert(err == 0);
292
-
293
- assert(argc == 1);
294
-
295
- bare_ffmpeg_format_context_t *context;
296
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
297
- assert(err == 0);
298
-
299
- avformat_close_input(&context->handle);
300
-
301
- return NULL;
302
- }
303
-
304
- static js_value_t *
305
- bare_ffmpeg_format_context_open_output(js_env_t *env, js_callback_info_t *info) {
306
- int err;
307
-
308
- size_t argc = 2;
309
- js_value_t *argv[2];
310
-
311
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
312
- assert(err == 0);
313
-
314
- assert(argc == 2);
315
-
316
- bare_ffmpeg_output_format_t *format;
317
- err = js_get_arraybuffer_info(env, argv[0], (void **) &format, NULL);
318
- assert(err == 0);
319
-
320
- bare_ffmpeg_io_context_t *io;
321
- err = js_get_arraybuffer_info(env, argv[1], (void **) &io, NULL);
322
- assert(err == 0);
323
-
324
- js_value_t *handle;
325
-
326
- bare_ffmpeg_format_context_t *context;
327
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_format_context_t), (void **) &context, &handle);
328
- assert(err == 0);
329
-
330
- err = avformat_alloc_output_context2(&context->handle, format->handle, NULL, NULL);
331
-
332
- if (err < 0) {
333
- err = js_throw_error(env, NULL, av_err2str(err));
334
- assert(err == 0);
335
-
336
- return NULL;
337
- }
338
-
339
- context->handle->pb = io->handle;
340
- context->handle->opaque = (void *) context;
341
-
342
- return handle;
343
- }
344
-
345
- static js_value_t *
346
- bare_ffmpeg_format_context_close_output(js_env_t *env, js_callback_info_t *info) {
347
- int err;
348
-
349
- size_t argc = 1;
350
- js_value_t *argv[1];
351
-
352
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
353
- assert(err == 0);
354
-
355
- assert(argc == 1);
356
-
357
- bare_ffmpeg_format_context_t *context;
358
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
359
- assert(err == 0);
360
-
361
- avformat_free_context(context->handle);
362
-
363
- return NULL;
364
- }
365
-
366
- static js_value_t *
367
- bare_ffmpeg_format_context_get_streams(js_env_t *env, js_callback_info_t *info) {
368
- int err;
369
-
370
- size_t argc = 1;
371
- js_value_t *argv[1];
372
-
373
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
374
- assert(err == 0);
375
-
376
- assert(argc == 1);
377
-
378
- bare_ffmpeg_format_context_t *context;
379
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
380
- assert(err == 0);
381
-
382
- uint32_t len = context->handle->nb_streams;
383
-
384
- js_value_t *result;
385
- err = js_create_array_with_length(env, len, &result);
386
- assert(err == 0);
387
-
388
- for (uint32_t i = 0; i < len; i++) {
389
- js_value_t *handle;
390
-
391
- bare_ffmpeg_stream_t *stream;
392
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_stream_t), (void **) &stream, &handle);
393
- assert(err == 0);
394
-
395
- stream->handle = context->handle->streams[i];
396
-
397
- err = js_set_element(env, result, i, handle);
398
- assert(err == 0);
399
- }
400
-
401
- return result;
402
- }
403
-
404
- static js_value_t *
405
- bare_ffmpeg_format_context_create_stream(js_env_t *env, js_callback_info_t *info) {
406
- int err;
407
-
408
- size_t argc = 2;
409
- js_value_t *argv[2];
410
-
411
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
412
- assert(err == 0);
413
-
414
- assert(argc == 2);
415
-
416
- bare_ffmpeg_format_context_t *context;
417
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
418
- assert(err == 0);
419
-
420
- bare_ffmpeg_codec_t *codec;
421
- err = js_get_arraybuffer_info(env, argv[1], (void **) &codec, NULL);
422
- assert(err == 0);
423
-
424
- js_value_t *handle;
425
-
426
- bare_ffmpeg_stream_t *stream;
427
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_stream_t), (void **) &stream, &handle);
428
- assert(err == 0);
429
-
430
- stream->handle = avformat_new_stream(context->handle, codec->handle);
431
-
432
- if (stream->handle == NULL) {
433
- err = js_throw_error(env, NULL, av_err2str(err));
434
- assert(err == 0);
435
-
436
- return NULL;
437
- }
438
-
439
- return handle;
440
- }
441
-
442
- static js_value_t *
443
- bare_ffmpeg_format_context_read_frame(js_env_t *env, js_callback_info_t *info) {
444
- int err;
445
-
446
- size_t argc = 2;
447
- js_value_t *argv[2];
448
-
449
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
450
- assert(err == 0);
451
-
452
- assert(argc == 2);
453
-
454
- bare_ffmpeg_format_context_t *context;
455
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
456
- assert(err == 0);
457
-
458
- bare_ffmpeg_packet_t *packet;
459
- err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
460
- assert(err == 0);
461
-
462
- av_packet_unref(&packet->handle);
463
-
464
- err = av_read_frame(context->handle, &packet->handle);
465
-
466
- if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
467
- err = js_throw_error(env, NULL, av_err2str(err));
468
- assert(err == 0);
469
- }
470
-
471
- js_value_t *result;
472
- err = js_get_boolean(env, err == 0, &result);
473
- assert(err == 0);
474
-
475
- return result;
476
- }
477
-
478
- static js_value_t *
479
- bare_ffmpeg_stream_get_codec(js_env_t *env, js_callback_info_t *info) {
480
- int err;
481
-
482
- size_t argc = 1;
483
- js_value_t *argv[1];
484
-
485
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
486
- assert(err == 0);
487
-
488
- assert(argc == 1);
489
-
490
- bare_ffmpeg_stream_t *stream;
491
- err = js_get_arraybuffer_info(env, argv[0], (void **) &stream, NULL);
492
- assert(err == 0);
493
-
494
- js_value_t *id;
495
- err = js_create_uint32(env, stream->handle->codecpar->codec_id, &id);
496
- assert(err == 0);
497
-
498
- return id;
499
- }
500
-
501
- static js_value_t *
502
- bare_ffmpeg_stream_get_codec_parameters(js_env_t *env, js_callback_info_t *info) {
503
- int err;
504
-
505
- size_t argc = 1;
506
- js_value_t *argv[1];
507
-
508
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
509
- assert(err == 0);
510
-
511
- assert(argc == 1);
512
-
513
- bare_ffmpeg_stream_t *stream;
514
- err = js_get_arraybuffer_info(env, argv[0], (void **) &stream, NULL);
515
- assert(err == 0);
516
-
517
- js_value_t *handle;
518
-
519
- bare_ffmpeg_codec_parameters_t *parameters;
520
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_parameters_t), (void **) &parameters, &handle);
521
- assert(err == 0);
522
-
523
- parameters->handle = stream->handle->codecpar;
524
-
525
- return handle;
526
- }
527
-
528
- static js_value_t *
529
- bare_ffmpeg_find_decoder_by_id(js_env_t *env, js_callback_info_t *info) {
530
- int err;
531
-
532
- size_t argc = 1;
533
- js_value_t *argv[1];
534
-
535
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
536
- assert(err == 0);
537
-
538
- assert(argc == 1);
539
-
540
- uint32_t id;
541
- err = js_get_value_uint32(env, argv[0], &id);
542
- assert(err == 0);
543
-
544
- const AVCodec *decoder = avcodec_find_decoder((enum AVCodecID) id);
545
-
546
- if (decoder == NULL) {
547
- err = js_throw_errorf(env, NULL, "No decoder found for codec '%d'", id);
548
- assert(err == 0);
549
-
550
- return NULL;
551
- }
552
-
553
- js_value_t *handle;
554
-
555
- bare_ffmpeg_codec_t *context;
556
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_t), (void **) &context, &handle);
557
- assert(err == 0);
558
-
559
- context->handle = decoder;
560
-
561
- return handle;
562
- }
563
-
564
- static js_value_t *
565
- bare_ffmpeg_find_encoder_by_id(js_env_t *env, js_callback_info_t *info) {
566
- int err;
567
-
568
- size_t argc = 1;
569
- js_value_t *argv[1];
570
-
571
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
572
- assert(err == 0);
573
-
574
- assert(argc == 1);
575
-
576
- uint32_t id;
577
- err = js_get_value_uint32(env, argv[0], &id);
578
- assert(err == 0);
579
-
580
- const AVCodec *encoder = avcodec_find_encoder((enum AVCodecID) id);
581
-
582
- if (encoder == NULL) {
583
- err = js_throw_errorf(env, NULL, "No encoder found for codec '%d'", id);
584
- assert(err == 0);
585
-
586
- return NULL;
587
- }
588
-
589
- js_value_t *handle;
590
-
591
- bare_ffmpeg_codec_t *context;
592
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_t), (void **) &context, &handle);
593
- assert(err == 0);
594
-
595
- context->handle = encoder;
596
-
597
- return handle;
598
- }
599
-
600
- static js_value_t *
601
- bare_ffmpeg_codec_context_init(js_env_t *env, js_callback_info_t *info) {
602
- int err;
603
-
604
- size_t argc = 1;
605
- js_value_t *argv[1];
606
-
607
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
608
- assert(err == 0);
609
-
610
- assert(argc == 1);
611
-
612
- bare_ffmpeg_codec_t *codec;
613
- err = js_get_arraybuffer_info(env, argv[0], (void **) &codec, NULL);
614
- assert(err == 0);
615
-
616
- js_value_t *handle;
617
-
618
- bare_ffmpeg_codec_context_t *context;
619
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_context_t), (void **) &context, &handle);
620
- assert(err == 0);
621
-
622
- context->handle = avcodec_alloc_context3(codec->handle);
623
-
624
- context->handle->opaque = (void *) context;
625
-
626
- return handle;
627
- }
628
-
629
- static js_value_t *
630
- bare_ffmpeg_codec_context_destroy(js_env_t *env, js_callback_info_t *info) {
631
- int err;
632
-
633
- size_t argc = 1;
634
- js_value_t *argv[1];
635
-
636
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
637
- assert(err == 0);
638
-
639
- assert(argc == 1);
640
-
641
- bare_ffmpeg_codec_context_t *context;
642
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
643
- assert(err == 0);
644
-
645
- avcodec_free_context(&context->handle);
646
-
647
- return NULL;
648
- }
649
-
650
- static js_value_t *
651
- bare_ffmpeg_codec_context_open(js_env_t *env, js_callback_info_t *info) {
652
- int err;
653
-
654
- size_t argc = 1;
655
- js_value_t *argv[1];
656
-
657
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
658
- assert(err == 0);
659
-
660
- assert(argc == 1);
661
-
662
- bare_ffmpeg_codec_context_t *context;
663
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
664
- assert(err == 0);
665
-
666
- err = avcodec_open2(context->handle, context->handle->codec, NULL);
667
-
668
- if (err < 0) {
669
- err = js_throw_error(env, NULL, av_err2str(err));
670
- assert(err == 0);
671
- }
672
-
673
- return NULL;
674
- }
675
-
676
- static js_value_t *
677
- bare_ffmpeg_codec_context_get_pixel_format(js_env_t *env, js_callback_info_t *info) {
678
- int err;
679
-
680
- size_t argc = 1;
681
- js_value_t *argv[1];
682
-
683
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
684
- assert(err == 0);
685
-
686
- assert(argc == 1);
687
-
688
- bare_ffmpeg_codec_context_t *context;
689
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
690
- assert(err == 0);
691
-
692
- js_value_t *result;
693
- err = js_create_int64(env, context->handle->pix_fmt, &result);
694
- assert(err == 0);
695
-
696
- return result;
697
- }
698
-
699
- static js_value_t *
700
- bare_ffmpeg_codec_context_set_pixel_format(js_env_t *env, js_callback_info_t *info) {
701
- int err;
702
-
703
- size_t argc = 2;
704
- js_value_t *argv[2];
705
-
706
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
707
- assert(err == 0);
708
-
709
- assert(argc == 2);
710
-
711
- bare_ffmpeg_codec_context_t *context;
712
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
713
- assert(err == 0);
714
-
715
- int64_t value;
716
- err = js_get_value_int64(env, argv[1], &value);
717
- assert(err == 0);
718
-
719
- context->handle->pix_fmt = value;
720
-
721
- return NULL;
722
- }
723
-
724
- static js_value_t *
725
- bare_ffmpeg_codec_context_get_width(js_env_t *env, js_callback_info_t *info) {
726
- int err;
727
-
728
- size_t argc = 1;
729
- js_value_t *argv[1];
730
-
731
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
732
- assert(err == 0);
733
-
734
- assert(argc == 1);
735
-
736
- bare_ffmpeg_codec_context_t *context;
737
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
738
- assert(err == 0);
739
-
740
- js_value_t *result;
741
- err = js_create_int64(env, context->handle->width, &result);
742
- assert(err == 0);
743
-
744
- return result;
745
- }
746
-
747
- static js_value_t *
748
- bare_ffmpeg_codec_context_set_width(js_env_t *env, js_callback_info_t *info) {
749
- int err;
750
-
751
- size_t argc = 2;
752
- js_value_t *argv[2];
753
-
754
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
755
- assert(err == 0);
756
-
757
- assert(argc == 2);
758
-
759
- bare_ffmpeg_codec_context_t *context;
760
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
761
- assert(err == 0);
762
-
763
- int64_t value;
764
- err = js_get_value_int64(env, argv[1], &value);
765
- assert(err == 0);
766
-
767
- context->handle->width = value;
768
-
769
- return NULL;
770
- }
771
-
772
- static js_value_t *
773
- bare_ffmpeg_codec_context_get_height(js_env_t *env, js_callback_info_t *info) {
774
- int err;
775
-
776
- size_t argc = 1;
777
- js_value_t *argv[1];
778
-
779
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
780
- assert(err == 0);
781
-
782
- assert(argc == 1);
783
-
784
- bare_ffmpeg_codec_context_t *context;
785
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
786
- assert(err == 0);
787
-
788
- js_value_t *result;
789
- err = js_create_int64(env, context->handle->height, &result);
790
- assert(err == 0);
791
-
792
- return result;
793
- }
794
-
795
- static js_value_t *
796
- bare_ffmpeg_codec_context_set_height(js_env_t *env, js_callback_info_t *info) {
797
- int err;
798
-
799
- size_t argc = 2;
800
- js_value_t *argv[2];
801
-
802
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
803
- assert(err == 0);
804
-
805
- assert(argc == 2);
806
-
807
- bare_ffmpeg_codec_context_t *context;
808
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
809
- assert(err == 0);
810
-
811
- int64_t value;
812
- err = js_get_value_int64(env, argv[1], &value);
813
- assert(err == 0);
814
-
815
- context->handle->height = value;
816
-
817
- return NULL;
818
- }
819
-
820
- static js_value_t *
821
- bare_ffmpeg_codec_context_get_time_base(js_env_t *env, js_callback_info_t *info) {
822
- int err;
823
-
824
- size_t argc = 1;
825
- js_value_t *argv[1];
826
-
827
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
828
- assert(err == 0);
829
-
830
- assert(argc == 1);
831
-
832
- bare_ffmpeg_codec_context_t *context;
833
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
834
- assert(err == 0);
835
-
836
- js_value_t *result;
837
-
838
- int32_t *data;
839
- err = js_create_arraybuffer(env, 2 * sizeof(int32_t), (void **) &data, &result);
840
- assert(err == 0);
841
-
842
- data[0] = context->handle->time_base.num;
843
- data[1] = context->handle->time_base.den;
844
-
845
- return result;
846
- }
847
-
848
- static js_value_t *
849
- bare_ffmpeg_codec_context_set_time_base(js_env_t *env, js_callback_info_t *info) {
850
- int err;
851
-
852
- size_t argc = 2;
853
- js_value_t *argv[2];
854
-
855
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
856
- assert(err == 0);
857
-
858
- assert(argc == 2);
859
-
860
- bare_ffmpeg_codec_context_t *context;
861
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
862
- assert(err == 0);
863
-
864
- int32_t *value;
865
- err = js_get_arraybuffer_info(env, argv[1], (void **) &value, NULL);
866
- assert(err == 0);
867
-
868
- context->handle->time_base.num = value[0];
869
- context->handle->time_base.den = value[1];
870
-
871
- return NULL;
872
- }
873
-
874
- static js_value_t *
875
- bare_ffmpeg_codec_context_send_packet(js_env_t *env, js_callback_info_t *info) {
876
- int err;
877
-
878
- size_t argc = 2;
879
- js_value_t *argv[2];
880
-
881
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
882
- assert(err == 0);
883
-
884
- assert(argc == 2);
885
-
886
- bare_ffmpeg_codec_context_t *context;
887
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
888
- assert(err == 0);
889
-
890
- bare_ffmpeg_packet_t *packet;
891
- err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
892
- assert(err == 0);
893
-
894
- err = avcodec_send_packet(context->handle, &packet->handle);
895
-
896
- if (err < 0) {
897
- err = js_throw_error(env, NULL, av_err2str(err));
898
- assert(err == 0);
899
- }
900
-
901
- return NULL;
902
- }
903
-
904
- static js_value_t *
905
- bare_ffmpeg_codec_context_receive_frame(js_env_t *env, js_callback_info_t *info) {
906
- int err;
907
-
908
- size_t argc = 2;
909
- js_value_t *argv[2];
910
-
911
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
912
- assert(err == 0);
913
-
914
- assert(argc == 2);
915
-
916
- bare_ffmpeg_codec_context_t *context;
917
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
918
- assert(err == 0);
919
-
920
- bare_ffmpeg_frame_t *frame;
921
- err = js_get_arraybuffer_info(env, argv[1], (void **) &frame, NULL);
922
- assert(err == 0);
923
-
924
- err = avcodec_receive_frame(context->handle, frame->handle);
925
-
926
- if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
927
- err = js_throw_error(env, NULL, av_err2str(err));
928
- assert(err == 0);
929
-
930
- return NULL;
931
- }
932
-
933
- js_value_t *result;
934
- err = js_get_boolean(env, err == 0, &result);
935
- assert(err == 0);
936
-
937
- return result;
938
- }
939
-
940
- static js_value_t *
941
- bare_ffmpeg_codec_parameters_from_context(js_env_t *env, js_callback_info_t *info) {
942
- int err;
943
-
944
- size_t argc = 2;
945
- js_value_t *argv[2];
946
-
947
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
948
- assert(err == 0);
949
-
950
- assert(argc == 2);
951
-
952
- bare_ffmpeg_codec_parameters_t *parameters;
953
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
954
- assert(err == 0);
955
-
956
- bare_ffmpeg_codec_context_t *context;
957
- err = js_get_arraybuffer_info(env, argv[1], (void **) &context, NULL);
958
- assert(err == 0);
959
-
960
- err = avcodec_parameters_from_context(parameters->handle, context->handle);
961
-
962
- if (err < 0) {
963
- err = js_throw_error(env, NULL, av_err2str(err));
964
- assert(err == 0);
965
-
966
- return NULL;
967
- }
968
-
969
- return NULL;
970
- }
971
-
972
- static js_value_t *
973
- bare_ffmpeg_codec_parameters_to_context(js_env_t *env, js_callback_info_t *info) {
974
- int err;
975
-
976
- size_t argc = 2;
977
- js_value_t *argv[2];
978
-
979
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
980
- assert(err == 0);
981
-
982
- assert(argc == 2);
983
-
984
- bare_ffmpeg_codec_context_t *context;
985
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
986
- assert(err == 0);
987
-
988
- bare_ffmpeg_codec_parameters_t *parameters;
989
- err = js_get_arraybuffer_info(env, argv[1], (void **) &parameters, NULL);
990
- assert(err == 0);
991
-
992
- err = avcodec_parameters_to_context(context->handle, parameters->handle);
993
-
994
- if (err < 0) {
995
- err = js_throw_error(env, NULL, av_err2str(err));
996
- assert(err == 0);
997
-
998
- return NULL;
999
- }
1000
-
1001
- return NULL;
1002
- }
1003
-
1004
- static js_value_t *
1005
- bare_ffmpeg_codec_parameters_get_bit_rate(js_env_t *env, js_callback_info_t *info) {
1006
- int err;
1007
-
1008
- size_t argc = 1;
1009
- js_value_t *argv[1];
1010
-
1011
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1012
- assert(err == 0);
1013
-
1014
- assert(argc == 1);
1015
-
1016
- bare_ffmpeg_codec_parameters_t *parameters;
1017
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1018
- assert(err == 0);
1019
-
1020
- js_value_t *result;
1021
- err = js_create_int64(env, parameters->handle->bit_rate, &result);
1022
- assert(err == 0);
1023
-
1024
- return result;
1025
- }
1026
-
1027
- static js_value_t *
1028
- bare_ffmpeg_codec_parameters_get_bits_per_coded_sample(js_env_t *env, js_callback_info_t *info) {
1029
- int err;
1030
-
1031
- size_t argc = 1;
1032
- js_value_t *argv[1];
1033
-
1034
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1035
- assert(err == 0);
1036
-
1037
- assert(argc == 1);
1038
-
1039
- bare_ffmpeg_codec_parameters_t *parameters;
1040
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1041
- assert(err == 0);
1042
-
1043
- js_value_t *result;
1044
- err = js_create_int64(env, parameters->handle->bits_per_coded_sample, &result);
1045
- assert(err == 0);
1046
-
1047
- return result;
1048
- }
1049
-
1050
- static js_value_t *
1051
- bare_ffmpeg_codec_parameters_get_bits_per_raw_sample(js_env_t *env, js_callback_info_t *info) {
1052
- int err;
1053
-
1054
- size_t argc = 1;
1055
- js_value_t *argv[1];
1056
-
1057
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1058
- assert(err == 0);
1059
-
1060
- assert(argc == 1);
1061
-
1062
- bare_ffmpeg_codec_parameters_t *parameters;
1063
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1064
- assert(err == 0);
1065
-
1066
- js_value_t *result;
1067
- err = js_create_int64(env, parameters->handle->bits_per_raw_sample, &result);
1068
- assert(err == 0);
1069
-
1070
- return result;
1071
- }
1072
-
1073
- static js_value_t *
1074
- bare_ffmpeg_codec_parameters_get_sample_rate(js_env_t *env, js_callback_info_t *info) {
1075
- int err;
1076
-
1077
- size_t argc = 1;
1078
- js_value_t *argv[1];
1079
-
1080
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1081
- assert(err == 0);
1082
-
1083
- assert(argc == 1);
1084
-
1085
- bare_ffmpeg_codec_parameters_t *parameters;
1086
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1087
- assert(err == 0);
1088
-
1089
- js_value_t *result;
1090
- err = js_create_int64(env, parameters->handle->sample_rate, &result);
1091
- assert(err == 0);
1092
-
1093
- return result;
1094
- }
1095
-
1096
- static js_value_t *
1097
- bare_ffmpeg_frame_init(js_env_t *env, js_callback_info_t *info) {
1098
- int err;
1099
-
1100
- js_value_t *handle;
1101
-
1102
- bare_ffmpeg_frame_t *frame;
1103
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_frame_t), (void **) &frame, &handle);
1104
- assert(err == 0);
1105
-
1106
- frame->handle = av_frame_alloc();
1107
-
1108
- frame->handle->opaque = (void *) frame;
1109
-
1110
- return handle;
1111
- }
1112
-
1113
- static js_value_t *
1114
- bare_ffmpeg_frame_destroy(js_env_t *env, js_callback_info_t *info) {
1115
- int err;
1116
-
1117
- size_t argc = 1;
1118
- js_value_t *argv[1];
1119
-
1120
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1121
- assert(err == 0);
1122
-
1123
- assert(argc == 1);
1124
-
1125
- bare_ffmpeg_frame_t *frame;
1126
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1127
- assert(err == 0);
1128
-
1129
- av_frame_free(&frame->handle);
1130
-
1131
- return NULL;
1132
- }
1133
-
1134
- static js_value_t *
1135
- bare_ffmpeg_frame_get_channel(js_env_t *env, js_callback_info_t *info) {
1136
- int err;
1137
-
1138
- size_t argc = 2;
1139
- js_value_t *argv[2];
1140
-
1141
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1142
- assert(err == 0);
1143
-
1144
- assert(argc == 2);
1145
-
1146
- bare_ffmpeg_frame_t *frame;
1147
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1148
- assert(err == 0);
1149
-
1150
- uint32_t i;
1151
- err = js_get_value_uint32(env, argv[1], &i);
1152
- assert(err == 0);
1153
-
1154
- assert(i < AV_NUM_DATA_POINTERS);
1155
-
1156
- js_value_t *result;
1157
-
1158
- size_t len = frame->handle->linesize[i];
1159
-
1160
- void *data;
1161
- err = js_create_unsafe_arraybuffer(env, len, &data, &result);
1162
- assert(err == 0);
1163
-
1164
- memcpy(data, frame->handle->data[i], len);
1165
-
1166
- return result;
1167
- }
1168
-
1169
- static js_value_t *
1170
- bare_ffmpeg_frame_get_width(js_env_t *env, js_callback_info_t *info) {
1171
- int err;
1172
-
1173
- size_t argc = 1;
1174
- js_value_t *argv[1];
1175
-
1176
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1177
- assert(err == 0);
1178
- assert(argc == 1);
1179
-
1180
- bare_ffmpeg_frame_t *frame;
1181
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1182
- assert(err == 0);
1183
-
1184
- js_value_t *result;
1185
- err = js_create_int32(env, frame->handle->width, &result);
1186
- assert(err == 0);
1187
-
1188
- return result;
1189
- }
1190
-
1191
- static js_value_t *
1192
- bare_ffmpeg_frame_set_width(js_env_t *env, js_callback_info_t *info) {
1193
- int err;
1194
-
1195
- size_t argc = 2;
1196
- js_value_t *argv[2];
1197
-
1198
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1199
- assert(err == 0);
1200
- assert(argc == 2);
1201
-
1202
- bare_ffmpeg_frame_t *frame;
1203
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1204
- assert(err == 0);
1205
-
1206
- int32_t width;
1207
- err = js_get_value_int32(env, argv[1], &width);
1208
- assert(err == 0);
1209
-
1210
- frame->handle->width = width;
1211
-
1212
- return NULL;
1213
- }
1214
-
1215
- static js_value_t *
1216
- bare_ffmpeg_frame_get_height(js_env_t *env, js_callback_info_t *info) {
1217
- int err;
1218
-
1219
- size_t argc = 1;
1220
- js_value_t *argv[1];
1221
-
1222
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1223
- assert(err == 0);
1224
- assert(argc == 1);
1225
-
1226
- bare_ffmpeg_frame_t *frame;
1227
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1228
- assert(err == 0);
1229
-
1230
- js_value_t *result;
1231
- err = js_create_int32(env, frame->handle->height, &result);
1232
- assert(err == 0);
1233
-
1234
- return result;
1235
- }
1236
-
1237
- static js_value_t *
1238
- bare_ffmpeg_frame_set_height(js_env_t *env, js_callback_info_t *info) {
1239
- int err;
1240
-
1241
- size_t argc = 2;
1242
- js_value_t *argv[2];
1243
-
1244
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1245
- assert(err == 0);
1246
- assert(argc == 2);
1247
-
1248
- bare_ffmpeg_frame_t *frame;
1249
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1250
- assert(err == 0);
1251
-
1252
- int32_t height;
1253
- err = js_get_value_int32(env, argv[1], &height);
1254
- assert(err == 0);
1255
-
1256
- frame->handle->height = height;
1257
-
1258
- return NULL;
1259
- }
1260
-
1261
- static js_value_t *
1262
- bare_ffmpeg_frame_get_pixel_format(js_env_t *env, js_callback_info_t *info) {
1263
- int err;
1264
-
1265
- size_t argc = 1;
1266
- js_value_t *argv[1];
1267
-
1268
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1269
- assert(err == 0);
1270
- assert(argc == 1);
1271
-
1272
- bare_ffmpeg_frame_t *frame;
1273
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1274
- assert(err == 0);
1275
-
1276
- js_value_t *result;
1277
- err = js_create_int64(env, frame->handle->format, &result);
1278
- assert(err == 0);
1279
-
1280
- return result;
1281
- }
1282
-
1283
- static js_value_t *
1284
- bare_ffmpeg_frame_set_pixel_format(js_env_t *env, js_callback_info_t *info) {
1285
- int err;
1286
-
1287
- size_t argc = 2;
1288
- js_value_t *argv[2];
1289
-
1290
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1291
- assert(err == 0);
1292
- assert(argc == 2);
1293
-
1294
- bare_ffmpeg_frame_t *frame;
1295
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1296
- assert(err == 0);
1297
-
1298
- int64_t pixel_format;
1299
- err = js_get_value_int64(env, argv[1], &pixel_format);
1300
- assert(err == 0);
1301
-
1302
- frame->handle->format = (enum AVPixelFormat) pixel_format;
1303
-
1304
- return NULL;
1305
- }
1306
-
1307
- static js_value_t *
1308
- bare_ffmpeg_frame_alloc(js_env_t *env, js_callback_info_t *info) {
1309
- int err;
1310
-
1311
- size_t argc = 2;
1312
- js_value_t *argv[2];
1313
-
1314
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1315
- assert(err == 0);
1316
- assert(argc == 2);
1317
-
1318
- bare_ffmpeg_frame_t *frame;
1319
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1320
- assert(err == 0);
1321
- assert(frame->handle != NULL);
1322
-
1323
- int align;
1324
- err = js_get_value_int32(env, argv[1], &align);
1325
- assert(err == 0);
1326
- assert(frame->handle != NULL);
1327
-
1328
- err = av_frame_get_buffer(frame->handle, align);
1329
- if (err < 0) {
1330
- err = js_throw_error(env, NULL, av_err2str(err));
1331
- assert(err == 0);
1332
- return NULL;
1333
- }
1334
-
1335
- return NULL;
1336
- }
1337
-
1338
- static js_value_t *
1339
- bare_ffmpeg_image_init(js_env_t *env, js_callback_info_t *info) {
1340
- int err;
1341
-
1342
- size_t argc = 4;
1343
- js_value_t *argv[4];
1344
-
1345
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1346
- assert(err == 0);
1347
-
1348
- assert(argc == 4);
1349
-
1350
- int64_t format;
1351
- err = js_get_value_int64(env, argv[0], &format);
1352
- assert(err == 0);
1353
-
1354
- int32_t width;
1355
- err = js_get_value_int32(env, argv[1], &width);
1356
- assert(err == 0);
1357
-
1358
- int32_t height;
1359
- err = js_get_value_int32(env, argv[2], &height);
1360
- assert(err == 0);
1361
-
1362
- int32_t align;
1363
- err = js_get_value_int32(env, argv[3], &align);
1364
- assert(err == 0);
1365
-
1366
- size_t len = av_image_get_buffer_size((enum AVPixelFormat) format, width, height, align);
1367
-
1368
- js_value_t *handle;
1369
-
1370
- uint8_t *data;
1371
- err = js_create_arraybuffer(env, len, (void **) &data, &handle);
1372
- assert(err == 0);
1373
-
1374
- return handle;
1375
- }
1376
-
1377
- static js_value_t *
1378
- bare_ffmpeg_image_fill(js_env_t *env, js_callback_info_t *info) {
1379
- int err;
1380
-
1381
- size_t argc = 5;
1382
- js_value_t *argv[5];
1383
-
1384
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1385
- assert(err == 0);
1386
-
1387
- assert(argc == 5);
1388
-
1389
- int64_t pixel_format;
1390
- err = js_get_value_int64(env, argv[0], &pixel_format);
1391
- assert(err == 0);
1392
-
1393
- int32_t width;
1394
- err = js_get_value_int32(env, argv[1], &width);
1395
- assert(err == 0);
1396
-
1397
- int32_t height;
1398
- err = js_get_value_int32(env, argv[2], &height);
1399
- assert(err == 0);
1400
-
1401
- uint8_t *data;
1402
- err = js_get_arraybuffer_info(env, argv[3], (void **) &data, NULL);
1403
- assert(err == 0);
1404
-
1405
- bare_ffmpeg_frame_t *frame;
1406
- err = js_get_arraybuffer_info(env, argv[4], (void **) &frame, NULL);
1407
- assert(err == 0);
1408
-
1409
- err = av_image_fill_arrays(frame->handle->data, frame->handle->linesize, data, (enum AVPixelFormat) pixel_format, width, height, 1);
1410
- assert(err >= 0);
1411
-
1412
- return NULL;
1413
- }
1414
-
1415
- static js_value_t *
1416
- bare_ffmpeg_packet_init(js_env_t *env, js_callback_info_t *info) {
1417
- int err;
1418
-
1419
- js_value_t *handle;
1420
-
1421
- bare_ffmpeg_packet_t *packet;
1422
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_packet_t), (void **) &packet, &handle);
1423
- assert(err == 0);
1424
-
1425
- return handle;
1426
- }
1427
-
1428
- static js_value_t *
1429
- bare_ffmpeg_packet_destroy(js_env_t *env, js_callback_info_t *info) {
1430
- int err;
1431
-
1432
- size_t argc = 1;
1433
- js_value_t *argv[1];
1434
-
1435
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1436
- assert(err == 0);
1437
-
1438
- assert(argc == 1);
1439
-
1440
- bare_ffmpeg_packet_t *packet;
1441
- err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
1442
- assert(err == 0);
1443
-
1444
- av_packet_unref(&packet->handle);
1445
-
1446
- return NULL;
1447
- }
1448
-
1449
- static js_value_t *
1450
- bare_ffmpeg_packet_unref(js_env_t *env, js_callback_info_t *info) {
1451
- int err;
1452
-
1453
- size_t argc = 1;
1454
- js_value_t *argv[1];
1455
-
1456
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1457
- assert(err == 0);
1458
-
1459
- assert(argc == 1);
1460
-
1461
- bare_ffmpeg_packet_t *packet;
1462
- err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
1463
- assert(err == 0);
1464
-
1465
- av_packet_unref(&packet->handle);
1466
-
1467
- return NULL;
1468
- }
1469
-
1470
- static js_value_t *
1471
- bare_ffmpeg_scaler_init(js_env_t *env, js_callback_info_t *info) {
1472
- int err;
1473
-
1474
- size_t argc = 6;
1475
- js_value_t *argv[6];
1476
-
1477
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1478
- assert(err == 0);
1479
-
1480
- assert(argc == 6);
1481
-
1482
- int64_t source_format;
1483
- err = js_get_value_int64(env, argv[0], &source_format);
1484
- assert(err == 0);
1485
-
1486
- int32_t source_width;
1487
- err = js_get_value_int32(env, argv[1], &source_width);
1488
- assert(err == 0);
1489
-
1490
- int32_t source_height;
1491
- err = js_get_value_int32(env, argv[2], &source_height);
1492
- assert(err == 0);
1493
-
1494
- int64_t target_format;
1495
- err = js_get_value_int64(env, argv[3], &target_format);
1496
- assert(err == 0);
1497
-
1498
- int32_t target_width;
1499
- err = js_get_value_int32(env, argv[4], &target_width);
1500
- assert(err == 0);
1501
-
1502
- int32_t target_height;
1503
- err = js_get_value_int32(env, argv[5], &target_height);
1504
- assert(err == 0);
1505
-
1506
- js_value_t *handle;
1507
-
1508
- bare_ffmpeg_scaler_t *scaler;
1509
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_scaler_t), (void **) &scaler, &handle);
1510
- assert(err == 0);
1511
-
1512
- scaler->handle = sws_getContext(
1513
- source_width,
1514
- source_height,
1515
- (enum AVPixelFormat) source_format,
1516
- target_width,
1517
- target_height,
1518
- (enum AVPixelFormat) target_format,
1519
- SWS_BICUBIC,
1520
- NULL,
1521
- NULL,
1522
- NULL
1523
- );
1524
-
1525
- return handle;
1526
- }
1527
-
1528
- static js_value_t *
1529
- bare_ffmpeg_scaler_destroy(js_env_t *env, js_callback_info_t *info) {
1530
- int err;
1531
-
1532
- size_t argc = 1;
1533
- js_value_t *argv[1];
1534
-
1535
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1536
- assert(err == 0);
1537
-
1538
- assert(argc == 1);
1539
-
1540
- bare_ffmpeg_scaler_t *scaler;
1541
- err = js_get_arraybuffer_info(env, argv[0], (void **) &scaler, NULL);
1542
- assert(err == 0);
1543
-
1544
- sws_freeContext(scaler->handle);
1545
-
1546
- return NULL;
1547
- }
1548
-
1549
- static js_value_t *
1550
- bare_ffmpeg_scaler_scale(js_env_t *env, js_callback_info_t *info) {
1551
- int err;
1552
-
1553
- size_t argc = 5;
1554
- js_value_t *argv[5];
1555
-
1556
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1557
- assert(err == 0);
1558
-
1559
- assert(argc == 5);
1560
-
1561
- bare_ffmpeg_scaler_t *scaler;
1562
- err = js_get_arraybuffer_info(env, argv[0], (void **) &scaler, NULL);
1563
- assert(err == 0);
1564
-
1565
- bare_ffmpeg_frame_t *source;
1566
- err = js_get_arraybuffer_info(env, argv[1], (void **) &source, NULL);
1567
- assert(err == 0);
1568
-
1569
- int64_t y;
1570
- err = js_get_value_int64(env, argv[2], &y);
1571
- assert(err == 0);
1572
-
1573
- int64_t height;
1574
- err = js_get_value_int64(env, argv[3], &height);
1575
- assert(err == 0);
1576
-
1577
- bare_ffmpeg_frame_t *target;
1578
- err = js_get_arraybuffer_info(env, argv[4], (void **) &target, NULL);
1579
- assert(err == 0);
1580
-
1581
- height = sws_scale(
1582
- scaler->handle,
1583
- (const uint8_t *const *) source->handle->data,
1584
- source->handle->linesize,
1585
- y,
1586
- height,
1587
- target->handle->data,
1588
- target->handle->linesize
1589
- );
1590
-
1591
- js_value_t *result;
1592
- err = js_create_int64(env, height, &result);
1593
- assert(err == 0);
1594
-
1595
- return result;
1596
- }
1597
-
1598
- static js_value_t *
1599
- bare_ffmpeg_dictionary_init(js_env_t *env, js_callback_info_t *info) {
1600
- int err;
1601
- js_value_t *handle;
1602
-
1603
- bare_ffmpeg_dictionary_t *dict;
1604
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_dictionary_t), (void **) &dict, &handle);
1605
- assert(err == 0);
1606
-
1607
- dict->handle = NULL;
1608
-
1609
- return handle;
1610
- }
1611
-
1612
- static js_value_t *
1613
- bare_ffmpeg_dictionary_destroy(js_env_t *env, js_callback_info_t *info) {
1614
- int err;
1615
-
1616
- size_t argc = 1;
1617
- js_value_t *argv[1];
1618
-
1619
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1620
- assert(err == 0);
1621
- assert(argc == 1);
1622
-
1623
- bare_ffmpeg_dictionary_t *dict;
1624
- err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
1625
- assert(err == 0);
1626
-
1627
- av_dict_free(&dict->handle);
1628
-
1629
- return NULL;
1630
- }
1631
-
1632
- static js_value_t *
1633
- bare_ffmpeg_dictionary_set_entry(js_env_t *env, js_callback_info_t *info) {
1634
- int err;
1635
-
1636
- size_t argc = 3;
1637
- js_value_t *argv[3];
1638
-
1639
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1640
- assert(err == 0);
1641
- assert(argc == 3);
1642
-
1643
- bare_ffmpeg_dictionary_t *dict;
1644
- err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
1645
- assert(err == 0);
1646
-
1647
- size_t len;
1648
- err = js_get_value_string_utf8(env, argv[1], NULL, 0, &len);
1649
- assert(err == 0);
1650
-
1651
- len += +1 /* NULL */;
1652
-
1653
- utf8_t *key = malloc(len);
1654
- err = js_get_value_string_utf8(env, argv[1], key, len, NULL);
1655
- assert(err == 0);
1656
-
1657
- err = js_get_value_string_utf8(env, argv[2], NULL, 0, &len);
1658
- assert(err == 0);
1659
-
1660
- len += +1 /* NULL */;
1661
-
1662
- utf8_t *value = malloc(len);
1663
- err = js_get_value_string_utf8(env, argv[2], value, len, NULL);
1664
- assert(err == 0);
1665
-
1666
- err = av_dict_set(&dict->handle, (const char *) key, (const char *) value, 0);
1667
- assert(err == 0);
1668
- free(key);
1669
- free(value);
1670
-
1671
- return NULL;
1672
- }
1673
-
1674
- static js_value_t *
1675
- bare_ffmpeg_dictionary_get_entry(js_env_t *env, js_callback_info_t *info) {
1676
- int err;
1677
-
1678
- size_t argc = 2;
1679
- js_value_t *argv[2];
1680
-
1681
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1682
- assert(err == 0);
1683
- assert(argc == 2);
1684
-
1685
- bare_ffmpeg_dictionary_t *dict;
1686
- err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
1687
- assert(err == 0);
1688
-
1689
- size_t len;
1690
- err = js_get_value_string_utf8(env, argv[1], NULL, 0, &len);
1691
- assert(err == 0);
1692
-
1693
- len += +1 /* NULL */;
1694
-
1695
- utf8_t *key = malloc(len);
1696
- err = js_get_value_string_utf8(env, argv[1], key, len, NULL);
1697
- assert(err == 0);
1698
-
1699
- AVDictionaryEntry *entry = av_dict_get(dict->handle, (const char *) key, NULL, 0);
1700
- free(key);
1701
-
1702
- if (entry == NULL) {
1703
- js_value_t *result;
1704
- err = js_get_null(env, &result);
1705
- assert(err == 0);
1706
- return result;
1707
- }
1708
-
1709
- js_value_t *result;
1710
- err = js_create_string_utf8(env, (const utf8_t *) entry->value, -1, &result);
1711
- assert(err == 0);
1712
-
1713
- return result;
1714
- }
1715
-
1716
- static js_value_t *
1717
- bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
1718
- uv_once(&bare_ffmpeg__init_guard, bare_ffmpeg__on_init);
1719
-
1720
- int err;
1721
-
1722
- #define V(name, fn) \
1723
- { \
1724
- js_value_t *val; \
1725
- err = js_create_function(env, name, -1, fn, NULL, &val); \
1726
- assert(err == 0); \
1727
- err = js_set_named_property(env, exports, name, val); \
1728
- assert(err == 0); \
1729
- }
1730
-
1731
- V("initIOContext", bare_ffmpeg_io_context_init)
1732
- V("destroyIOContext", bare_ffmpeg_io_context_destroy)
1733
-
1734
- V("initOutputFormat", bare_ffmpeg_output_format_init)
1735
- V("initInputFormat", bare_ffmpeg_input_format_init)
1736
-
1737
- V("openInputFormatContext", bare_ffmpeg_format_context_open_input)
1738
- V("closeInputFormatContext", bare_ffmpeg_format_context_close_input)
1739
- V("openOutputFormatContext", bare_ffmpeg_format_context_open_output)
1740
- V("closeOutputFormatContext", bare_ffmpeg_format_context_close_output)
1741
- V("getFormatContextStreams", bare_ffmpeg_format_context_get_streams)
1742
- V("createFormatContextStream", bare_ffmpeg_format_context_create_stream)
1743
- V("readFormatContextFrame", bare_ffmpeg_format_context_read_frame)
1744
-
1745
- V("getStreamCodec", bare_ffmpeg_stream_get_codec)
1746
- V("getStreamCodecParameters", bare_ffmpeg_stream_get_codec_parameters)
1747
-
1748
- V("findDecoderByID", bare_ffmpeg_find_decoder_by_id)
1749
- V("findEncoderByID", bare_ffmpeg_find_encoder_by_id)
1750
-
1751
- V("initCodecContext", bare_ffmpeg_codec_context_init)
1752
- V("destroyCodecContext", bare_ffmpeg_codec_context_destroy)
1753
- V("openCodecContext", bare_ffmpeg_codec_context_open)
1754
- V("getCodecContextPixelFormat", bare_ffmpeg_codec_context_get_pixel_format)
1755
- V("setCodecContextPixelFormat", bare_ffmpeg_codec_context_set_pixel_format)
1756
- V("getCodecContextWidth", bare_ffmpeg_codec_context_get_width)
1757
- V("setCodecContextWidth", bare_ffmpeg_codec_context_set_width)
1758
- V("getCodecContextHeight", bare_ffmpeg_codec_context_get_height)
1759
- V("setCodecContextHeight", bare_ffmpeg_codec_context_set_height)
1760
- V("getCodecContextTimeBase", bare_ffmpeg_codec_context_get_time_base)
1761
- V("setCodecContextTimeBase", bare_ffmpeg_codec_context_set_time_base)
1762
- V("sendCodecContextPacket", bare_ffmpeg_codec_context_send_packet)
1763
- V("receiveCodecContextFrame", bare_ffmpeg_codec_context_receive_frame)
1764
-
1765
- V("codecParametersFromContext", bare_ffmpeg_codec_parameters_from_context)
1766
- V("codecParametersToContext", bare_ffmpeg_codec_parameters_to_context)
1767
- V("getCodecParametersBitRate", bare_ffmpeg_codec_parameters_get_bit_rate)
1768
- V("getCodecParametersBitsPerCodedSample", bare_ffmpeg_codec_parameters_get_bits_per_coded_sample)
1769
- V("getCodecParametersBitsPerRawSample", bare_ffmpeg_codec_parameters_get_bits_per_raw_sample)
1770
- V("getCodecParametersSampleRate", bare_ffmpeg_codec_parameters_get_sample_rate)
1771
-
1772
- V("initFrame", bare_ffmpeg_frame_init)
1773
- V("destroyFrame", bare_ffmpeg_frame_destroy)
1774
- V("getFrameChannel", bare_ffmpeg_frame_get_channel)
1775
- V("getFrameWidth", bare_ffmpeg_frame_get_width)
1776
- V("setFrameWidth", bare_ffmpeg_frame_set_width)
1777
- V("getFrameHeight", bare_ffmpeg_frame_get_height)
1778
- V("setFrameHeight", bare_ffmpeg_frame_set_height)
1779
- V("getFramePixelFormat", bare_ffmpeg_frame_get_pixel_format)
1780
- V("setFramePixelFormat", bare_ffmpeg_frame_set_pixel_format)
1781
- V("allocFrame", bare_ffmpeg_frame_alloc)
1782
-
1783
- V("initImage", bare_ffmpeg_image_init)
1784
- V("fillImage", bare_ffmpeg_image_fill)
1785
-
1786
- V("initPacket", bare_ffmpeg_packet_init)
1787
- V("destroyPacket", bare_ffmpeg_packet_destroy)
1788
- V("unrefPacket", bare_ffmpeg_packet_unref)
1789
-
1790
- V("initScaler", bare_ffmpeg_scaler_init)
1791
- V("destroyScaler", bare_ffmpeg_scaler_destroy)
1792
- V("scaleScaler", bare_ffmpeg_scaler_scale)
1793
-
1794
- V("initDictionary", bare_ffmpeg_dictionary_init)
1795
- V("destroyDictionary", bare_ffmpeg_dictionary_destroy)
1796
- V("getDictionaryEntry", bare_ffmpeg_dictionary_get_entry)
1797
- V("setDictionaryEntry", bare_ffmpeg_dictionary_set_entry)
1798
- #undef V
1799
-
1800
- #define V(name) \
1801
- { \
1802
- js_value_t *val; \
1803
- err = js_create_int64(env, name, &val); \
1804
- assert(err == 0); \
1805
- err = js_set_named_property(env, exports, #name, val); \
1806
- assert(err == 0); \
1807
- }
1808
-
1809
- V(AV_CODEC_ID_MJPEG)
1810
-
1811
- V(AV_PIX_FMT_RGBA)
1812
- V(AV_PIX_FMT_YUVJ420P)
1813
- V(AV_PIX_FMT_YUV420P)
1814
- #undef V
1815
-
1816
- return exports;
1817
- }
1818
-
1819
- BARE_MODULE(bare_ffmpeg, bare_ffmpeg_exports)