bare-ffmpeg 1.0.0-6 → 1.0.0-8

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,2184 +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
-
171
- free(name);
172
-
173
- return NULL;
174
- }
175
-
176
- free(name);
177
-
178
- js_value_t *handle;
179
-
180
- bare_ffmpeg_output_format_t *context;
181
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_output_format_t), (void **) &context, &handle);
182
- assert(err == 0);
183
-
184
- context->handle = format;
185
-
186
- return handle;
187
- }
188
-
189
- static js_value_t *
190
- bare_ffmpeg_input_format_init(js_env_t *env, js_callback_info_t *info) {
191
- int err;
192
-
193
- size_t argc = 1;
194
- js_value_t *argv[1];
195
-
196
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
197
- assert(err == 0);
198
-
199
- assert(argc == 1);
200
-
201
- size_t len;
202
- err = js_get_value_string_utf8(env, argv[0], NULL, 0, &len);
203
- assert(err == 0);
204
-
205
- len += +1 /* NULL */;
206
-
207
- utf8_t *name = malloc(len);
208
- err = js_get_value_string_utf8(env, argv[0], name, len, NULL);
209
- assert(err == 0);
210
-
211
- const AVInputFormat *format = av_find_input_format((const char *) name);
212
-
213
- if (format == NULL) {
214
- err = js_throw_errorf(env, NULL, "No input format found for name '%s'", name);
215
- assert(err == 0);
216
-
217
- free(name);
218
-
219
- return NULL;
220
- }
221
-
222
- free(name);
223
-
224
- js_value_t *handle;
225
-
226
- bare_ffmpeg_input_format_t *context;
227
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_input_format_t), (void **) &context, &handle);
228
- assert(err == 0);
229
-
230
- context->handle = format;
231
-
232
- return handle;
233
- }
234
-
235
- static js_value_t *
236
- bare_ffmpeg_format_context_open_input_with_io(js_env_t *env, js_callback_info_t *info) {
237
- int err;
238
-
239
- size_t argc = 1;
240
- js_value_t *argv[1];
241
-
242
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
243
- assert(err == 0);
244
-
245
- assert(argc == 1);
246
-
247
- bare_ffmpeg_io_context_t *io;
248
- err = js_get_arraybuffer_info(env, argv[0], (void **) &io, NULL);
249
- assert(err == 0);
250
-
251
- js_value_t *handle;
252
-
253
- bare_ffmpeg_format_context_t *context;
254
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_format_context_t), (void **) &context, &handle);
255
- assert(err == 0);
256
-
257
- context->handle = avformat_alloc_context();
258
-
259
- context->handle->pb = io->handle;
260
- context->handle->opaque = (void *) context;
261
-
262
- err = avformat_open_input(&context->handle, NULL, NULL, NULL);
263
-
264
- if (err < 0) {
265
- avformat_free_context(context->handle);
266
-
267
- err = js_throw_error(env, NULL, av_err2str(err));
268
- assert(err == 0);
269
-
270
- return NULL;
271
- }
272
-
273
- err = avformat_find_stream_info(context->handle, NULL);
274
-
275
- if (err < 0) {
276
- avformat_close_input(&context->handle);
277
-
278
- err = js_throw_error(env, NULL, av_err2str(err));
279
- assert(err == 0);
280
-
281
- return NULL;
282
- }
283
-
284
- return handle;
285
- }
286
-
287
- static js_value_t *
288
- bare_ffmpeg_format_context_open_input_with_format(js_env_t *env, js_callback_info_t *info) {
289
- int err;
290
-
291
- size_t argc = 3;
292
- js_value_t *argv[3];
293
-
294
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
295
- assert(err == 0);
296
- assert(argc == 3);
297
-
298
- bare_ffmpeg_input_format_t *format;
299
- err = js_get_arraybuffer_info(env, argv[0], (void **) &format, NULL);
300
- assert(err == 0);
301
-
302
- js_value_t *handle;
303
-
304
- bare_ffmpeg_format_context_t *context;
305
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_format_context_t), (void **) &context, &handle);
306
- assert(err == 0);
307
-
308
- context->handle = avformat_alloc_context();
309
-
310
- context->handle->opaque = (void *) context;
311
-
312
- bare_ffmpeg_dictionary_t *options;
313
- err = js_get_arraybuffer_info(env, argv[1], (void **) &options, NULL);
314
- assert(err == 0);
315
-
316
- size_t len;
317
- err = js_get_value_string_utf8(env, argv[2], NULL, 0, &len);
318
- assert(err == 0);
319
-
320
- len += +1 /* NULL */;
321
-
322
- utf8_t *url = malloc(len);
323
- err = js_get_value_string_utf8(env, argv[2], url, len, NULL);
324
- assert(err == 0);
325
-
326
- err = avformat_open_input(&context->handle, (char *) url, format->handle, &options->handle);
327
-
328
- free(url);
329
-
330
- if (err < 0) {
331
- avformat_free_context(context->handle);
332
-
333
- err = js_throw_error(env, NULL, av_err2str(err));
334
- assert(err == 0);
335
-
336
- return NULL;
337
- }
338
-
339
- err = avformat_find_stream_info(context->handle, NULL);
340
-
341
- if (err < 0) {
342
- avformat_close_input(&context->handle);
343
-
344
- err = js_throw_error(env, NULL, av_err2str(err));
345
- assert(err == 0);
346
-
347
- return NULL;
348
- }
349
-
350
- return handle;
351
- }
352
-
353
- static js_value_t *
354
- bare_ffmpeg_format_context_close_input(js_env_t *env, js_callback_info_t *info) {
355
- int err;
356
-
357
- size_t argc = 1;
358
- js_value_t *argv[1];
359
-
360
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
361
- assert(err == 0);
362
-
363
- assert(argc == 1);
364
-
365
- bare_ffmpeg_format_context_t *context;
366
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
367
- assert(err == 0);
368
-
369
- avformat_close_input(&context->handle);
370
-
371
- return NULL;
372
- }
373
-
374
- static js_value_t *
375
- bare_ffmpeg_format_context_open_output(js_env_t *env, js_callback_info_t *info) {
376
- int err;
377
-
378
- size_t argc = 2;
379
- js_value_t *argv[2];
380
-
381
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
382
- assert(err == 0);
383
-
384
- assert(argc == 2);
385
-
386
- bare_ffmpeg_output_format_t *format;
387
- err = js_get_arraybuffer_info(env, argv[0], (void **) &format, NULL);
388
- assert(err == 0);
389
-
390
- bare_ffmpeg_io_context_t *io;
391
- err = js_get_arraybuffer_info(env, argv[1], (void **) &io, NULL);
392
- assert(err == 0);
393
-
394
- js_value_t *handle;
395
-
396
- bare_ffmpeg_format_context_t *context;
397
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_format_context_t), (void **) &context, &handle);
398
- assert(err == 0);
399
-
400
- err = avformat_alloc_output_context2(&context->handle, format->handle, NULL, NULL);
401
-
402
- if (err < 0) {
403
- err = js_throw_error(env, NULL, av_err2str(err));
404
- assert(err == 0);
405
-
406
- return NULL;
407
- }
408
-
409
- context->handle->pb = io->handle;
410
- context->handle->opaque = (void *) context;
411
-
412
- return handle;
413
- }
414
-
415
- static js_value_t *
416
- bare_ffmpeg_format_context_close_output(js_env_t *env, js_callback_info_t *info) {
417
- int err;
418
-
419
- size_t argc = 1;
420
- js_value_t *argv[1];
421
-
422
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
423
- assert(err == 0);
424
-
425
- assert(argc == 1);
426
-
427
- bare_ffmpeg_format_context_t *context;
428
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
429
- assert(err == 0);
430
-
431
- avformat_free_context(context->handle);
432
-
433
- return NULL;
434
- }
435
-
436
- static js_value_t *
437
- bare_ffmpeg_format_context_get_streams(js_env_t *env, js_callback_info_t *info) {
438
- int err;
439
-
440
- size_t argc = 1;
441
- js_value_t *argv[1];
442
-
443
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
444
- assert(err == 0);
445
-
446
- assert(argc == 1);
447
-
448
- bare_ffmpeg_format_context_t *context;
449
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
450
- assert(err == 0);
451
-
452
- uint32_t len = context->handle->nb_streams;
453
-
454
- js_value_t *result;
455
- err = js_create_array_with_length(env, len, &result);
456
- assert(err == 0);
457
-
458
- for (uint32_t i = 0; i < len; i++) {
459
- js_value_t *handle;
460
-
461
- bare_ffmpeg_stream_t *stream;
462
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_stream_t), (void **) &stream, &handle);
463
- assert(err == 0);
464
-
465
- stream->handle = context->handle->streams[i];
466
-
467
- err = js_set_element(env, result, i, handle);
468
- assert(err == 0);
469
- }
470
-
471
- return result;
472
- }
473
-
474
- static js_value_t *
475
- bare_ffmpeg_format_context_get_best_stream_index(js_env_t *env, js_callback_info_t *info) {
476
- int err;
477
-
478
- size_t argc = 2;
479
- js_value_t *argv[2];
480
-
481
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
482
- assert(err == 0);
483
-
484
- assert(argc == 2);
485
-
486
- bare_ffmpeg_format_context_t *context;
487
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
488
- assert(err == 0);
489
-
490
- int type;
491
- err = js_get_value_int32(env, argv[1], &type);
492
- assert(err == 0);
493
-
494
- int i = av_find_best_stream(context->handle, type, -1, -1, NULL, 0);
495
-
496
- if (i < 0) i = -1;
497
-
498
- js_value_t *result;
499
- err = js_create_int32(env, i, &result);
500
- assert(err == 0);
501
-
502
- return result;
503
- }
504
-
505
- static js_value_t *
506
- bare_ffmpeg_format_context_create_stream(js_env_t *env, js_callback_info_t *info) {
507
- int err;
508
-
509
- size_t argc = 2;
510
- js_value_t *argv[2];
511
-
512
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
513
- assert(err == 0);
514
-
515
- assert(argc == 2);
516
-
517
- bare_ffmpeg_format_context_t *context;
518
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
519
- assert(err == 0);
520
-
521
- bare_ffmpeg_codec_t *codec;
522
- err = js_get_arraybuffer_info(env, argv[1], (void **) &codec, NULL);
523
- assert(err == 0);
524
-
525
- js_value_t *handle;
526
-
527
- bare_ffmpeg_stream_t *stream;
528
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_stream_t), (void **) &stream, &handle);
529
- assert(err == 0);
530
-
531
- stream->handle = avformat_new_stream(context->handle, codec->handle);
532
-
533
- if (stream->handle == NULL) {
534
- err = js_throw_error(env, NULL, av_err2str(err));
535
- assert(err == 0);
536
-
537
- return NULL;
538
- }
539
-
540
- return handle;
541
- }
542
-
543
- static js_value_t *
544
- bare_ffmpeg_format_context_read_frame(js_env_t *env, js_callback_info_t *info) {
545
- int err;
546
-
547
- size_t argc = 2;
548
- js_value_t *argv[2];
549
-
550
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
551
- assert(err == 0);
552
-
553
- assert(argc == 2);
554
-
555
- bare_ffmpeg_format_context_t *context;
556
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
557
- assert(err == 0);
558
-
559
- bare_ffmpeg_packet_t *packet;
560
- err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
561
- assert(err == 0);
562
-
563
- av_packet_unref(packet->handle);
564
-
565
- err = av_read_frame(context->handle, packet->handle);
566
-
567
- if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
568
- err = js_throw_error(env, NULL, av_err2str(err));
569
- assert(err == 0);
570
- }
571
-
572
- js_value_t *result;
573
- err = js_get_boolean(env, err == 0, &result);
574
- assert(err == 0);
575
-
576
- return result;
577
- }
578
-
579
- static js_value_t *
580
- bare_ffmpeg_stream_get_codec(js_env_t *env, js_callback_info_t *info) {
581
- int err;
582
-
583
- size_t argc = 1;
584
- js_value_t *argv[1];
585
-
586
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
587
- assert(err == 0);
588
-
589
- assert(argc == 1);
590
-
591
- bare_ffmpeg_stream_t *stream;
592
- err = js_get_arraybuffer_info(env, argv[0], (void **) &stream, NULL);
593
- assert(err == 0);
594
-
595
- js_value_t *id;
596
- err = js_create_uint32(env, stream->handle->codecpar->codec_id, &id);
597
- assert(err == 0);
598
-
599
- return id;
600
- }
601
-
602
- static js_value_t *
603
- bare_ffmpeg_stream_get_codec_parameters(js_env_t *env, js_callback_info_t *info) {
604
- int err;
605
-
606
- size_t argc = 1;
607
- js_value_t *argv[1];
608
-
609
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
610
- assert(err == 0);
611
-
612
- assert(argc == 1);
613
-
614
- bare_ffmpeg_stream_t *stream;
615
- err = js_get_arraybuffer_info(env, argv[0], (void **) &stream, NULL);
616
- assert(err == 0);
617
-
618
- js_value_t *handle;
619
-
620
- bare_ffmpeg_codec_parameters_t *parameters;
621
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_parameters_t), (void **) &parameters, &handle);
622
- assert(err == 0);
623
-
624
- parameters->handle = stream->handle->codecpar;
625
-
626
- return handle;
627
- }
628
-
629
- static js_value_t *
630
- bare_ffmpeg_find_decoder_by_id(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
- uint32_t id;
642
- err = js_get_value_uint32(env, argv[0], &id);
643
- assert(err == 0);
644
-
645
- const AVCodec *decoder = avcodec_find_decoder((enum AVCodecID) id);
646
-
647
- if (decoder == NULL) {
648
- err = js_throw_errorf(env, NULL, "No decoder found for codec '%d'", id);
649
- assert(err == 0);
650
-
651
- return NULL;
652
- }
653
-
654
- js_value_t *handle;
655
-
656
- bare_ffmpeg_codec_t *context;
657
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_t), (void **) &context, &handle);
658
- assert(err == 0);
659
-
660
- context->handle = decoder;
661
-
662
- return handle;
663
- }
664
-
665
- static js_value_t *
666
- bare_ffmpeg_find_encoder_by_id(js_env_t *env, js_callback_info_t *info) {
667
- int err;
668
-
669
- size_t argc = 1;
670
- js_value_t *argv[1];
671
-
672
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
673
- assert(err == 0);
674
-
675
- assert(argc == 1);
676
-
677
- uint32_t id;
678
- err = js_get_value_uint32(env, argv[0], &id);
679
- assert(err == 0);
680
-
681
- const AVCodec *encoder = avcodec_find_encoder((enum AVCodecID) id);
682
-
683
- if (encoder == NULL) {
684
- err = js_throw_errorf(env, NULL, "No encoder found for codec '%d'", id);
685
- assert(err == 0);
686
-
687
- return NULL;
688
- }
689
-
690
- js_value_t *handle;
691
-
692
- bare_ffmpeg_codec_t *context;
693
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_t), (void **) &context, &handle);
694
- assert(err == 0);
695
-
696
- context->handle = encoder;
697
-
698
- return handle;
699
- }
700
-
701
- static js_value_t *
702
- bare_ffmpeg_codec_context_init(js_env_t *env, js_callback_info_t *info) {
703
- int err;
704
-
705
- size_t argc = 1;
706
- js_value_t *argv[1];
707
-
708
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
709
- assert(err == 0);
710
-
711
- assert(argc == 1);
712
-
713
- bare_ffmpeg_codec_t *codec;
714
- err = js_get_arraybuffer_info(env, argv[0], (void **) &codec, NULL);
715
- assert(err == 0);
716
-
717
- js_value_t *handle;
718
-
719
- bare_ffmpeg_codec_context_t *context;
720
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_context_t), (void **) &context, &handle);
721
- assert(err == 0);
722
-
723
- context->handle = avcodec_alloc_context3(codec->handle);
724
-
725
- context->handle->opaque = (void *) context;
726
-
727
- return handle;
728
- }
729
-
730
- static js_value_t *
731
- bare_ffmpeg_codec_context_destroy(js_env_t *env, js_callback_info_t *info) {
732
- int err;
733
-
734
- size_t argc = 1;
735
- js_value_t *argv[1];
736
-
737
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
738
- assert(err == 0);
739
-
740
- assert(argc == 1);
741
-
742
- bare_ffmpeg_codec_context_t *context;
743
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
744
- assert(err == 0);
745
-
746
- avcodec_free_context(&context->handle);
747
-
748
- return NULL;
749
- }
750
-
751
- static js_value_t *
752
- bare_ffmpeg_codec_context_open(js_env_t *env, js_callback_info_t *info) {
753
- int err;
754
-
755
- size_t argc = 1;
756
- js_value_t *argv[1];
757
-
758
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
759
- assert(err == 0);
760
-
761
- assert(argc == 1);
762
-
763
- bare_ffmpeg_codec_context_t *context;
764
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
765
- assert(err == 0);
766
-
767
- err = avcodec_open2(context->handle, context->handle->codec, NULL);
768
-
769
- if (err < 0) {
770
- err = js_throw_error(env, NULL, av_err2str(err));
771
- assert(err == 0);
772
- }
773
-
774
- return NULL;
775
- }
776
-
777
- static js_value_t *
778
- bare_ffmpeg_codec_context_open_with_options(js_env_t *env, js_callback_info_t *info) {
779
- int err;
780
-
781
- size_t argc = 2;
782
- js_value_t *argv[2];
783
-
784
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
785
- assert(err == 0);
786
-
787
- assert(argc == 2);
788
-
789
- bare_ffmpeg_codec_context_t *context;
790
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
791
- assert(err == 0);
792
-
793
- bare_ffmpeg_dictionary_t *options;
794
- err = js_get_arraybuffer_info(env, argv[1], (void **) &options, NULL);
795
- assert(err == 0);
796
-
797
- err = avcodec_open2(context->handle, context->handle->codec, &options->handle);
798
-
799
- if (err < 0) {
800
- err = js_throw_error(env, NULL, av_err2str(err));
801
- assert(err == 0);
802
- }
803
-
804
- return NULL;
805
- }
806
-
807
- static js_value_t *
808
- bare_ffmpeg_codec_context_get_pixel_format(js_env_t *env, js_callback_info_t *info) {
809
- int err;
810
-
811
- size_t argc = 1;
812
- js_value_t *argv[1];
813
-
814
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
815
- assert(err == 0);
816
-
817
- assert(argc == 1);
818
-
819
- bare_ffmpeg_codec_context_t *context;
820
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
821
- assert(err == 0);
822
-
823
- js_value_t *result;
824
- err = js_create_int64(env, context->handle->pix_fmt, &result);
825
- assert(err == 0);
826
-
827
- return result;
828
- }
829
-
830
- static js_value_t *
831
- bare_ffmpeg_codec_context_set_pixel_format(js_env_t *env, js_callback_info_t *info) {
832
- int err;
833
-
834
- size_t argc = 2;
835
- js_value_t *argv[2];
836
-
837
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
838
- assert(err == 0);
839
-
840
- assert(argc == 2);
841
-
842
- bare_ffmpeg_codec_context_t *context;
843
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
844
- assert(err == 0);
845
-
846
- int64_t value;
847
- err = js_get_value_int64(env, argv[1], &value);
848
- assert(err == 0);
849
-
850
- context->handle->pix_fmt = value;
851
-
852
- return NULL;
853
- }
854
-
855
- static js_value_t *
856
- bare_ffmpeg_codec_context_get_width(js_env_t *env, js_callback_info_t *info) {
857
- int err;
858
-
859
- size_t argc = 1;
860
- js_value_t *argv[1];
861
-
862
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
863
- assert(err == 0);
864
-
865
- assert(argc == 1);
866
-
867
- bare_ffmpeg_codec_context_t *context;
868
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
869
- assert(err == 0);
870
-
871
- js_value_t *result;
872
- err = js_create_int64(env, context->handle->width, &result);
873
- assert(err == 0);
874
-
875
- return result;
876
- }
877
-
878
- static js_value_t *
879
- bare_ffmpeg_codec_context_set_width(js_env_t *env, js_callback_info_t *info) {
880
- int err;
881
-
882
- size_t argc = 2;
883
- js_value_t *argv[2];
884
-
885
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
886
- assert(err == 0);
887
-
888
- assert(argc == 2);
889
-
890
- bare_ffmpeg_codec_context_t *context;
891
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
892
- assert(err == 0);
893
-
894
- int64_t value;
895
- err = js_get_value_int64(env, argv[1], &value);
896
- assert(err == 0);
897
-
898
- context->handle->width = value;
899
-
900
- return NULL;
901
- }
902
-
903
- static js_value_t *
904
- bare_ffmpeg_codec_context_get_height(js_env_t *env, js_callback_info_t *info) {
905
- int err;
906
-
907
- size_t argc = 1;
908
- js_value_t *argv[1];
909
-
910
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
911
- assert(err == 0);
912
-
913
- assert(argc == 1);
914
-
915
- bare_ffmpeg_codec_context_t *context;
916
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
917
- assert(err == 0);
918
-
919
- js_value_t *result;
920
- err = js_create_int64(env, context->handle->height, &result);
921
- assert(err == 0);
922
-
923
- return result;
924
- }
925
-
926
- static js_value_t *
927
- bare_ffmpeg_codec_context_set_height(js_env_t *env, js_callback_info_t *info) {
928
- int err;
929
-
930
- size_t argc = 2;
931
- js_value_t *argv[2];
932
-
933
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
934
- assert(err == 0);
935
-
936
- assert(argc == 2);
937
-
938
- bare_ffmpeg_codec_context_t *context;
939
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
940
- assert(err == 0);
941
-
942
- int64_t value;
943
- err = js_get_value_int64(env, argv[1], &value);
944
- assert(err == 0);
945
-
946
- context->handle->height = value;
947
-
948
- return NULL;
949
- }
950
-
951
- static js_value_t *
952
- bare_ffmpeg_codec_context_get_time_base(js_env_t *env, js_callback_info_t *info) {
953
- int err;
954
-
955
- size_t argc = 1;
956
- js_value_t *argv[1];
957
-
958
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
959
- assert(err == 0);
960
-
961
- assert(argc == 1);
962
-
963
- bare_ffmpeg_codec_context_t *context;
964
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
965
- assert(err == 0);
966
-
967
- js_value_t *result;
968
-
969
- int32_t *data;
970
- err = js_create_arraybuffer(env, 2 * sizeof(int32_t), (void **) &data, &result);
971
- assert(err == 0);
972
-
973
- data[0] = context->handle->time_base.num;
974
- data[1] = context->handle->time_base.den;
975
-
976
- return result;
977
- }
978
-
979
- static js_value_t *
980
- bare_ffmpeg_codec_context_set_time_base(js_env_t *env, js_callback_info_t *info) {
981
- int err;
982
-
983
- size_t argc = 2;
984
- js_value_t *argv[2];
985
-
986
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
987
- assert(err == 0);
988
-
989
- assert(argc == 2);
990
-
991
- bare_ffmpeg_codec_context_t *context;
992
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
993
- assert(err == 0);
994
-
995
- int32_t *value;
996
- err = js_get_arraybuffer_info(env, argv[1], (void **) &value, NULL);
997
- assert(err == 0);
998
-
999
- context->handle->time_base.num = value[0];
1000
- context->handle->time_base.den = value[1];
1001
-
1002
- return NULL;
1003
- }
1004
-
1005
- static js_value_t *
1006
- bare_ffmpeg_codec_context_send_packet(js_env_t *env, js_callback_info_t *info) {
1007
- int err;
1008
-
1009
- size_t argc = 2;
1010
- js_value_t *argv[2];
1011
-
1012
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1013
- assert(err == 0);
1014
-
1015
- assert(argc == 2);
1016
-
1017
- bare_ffmpeg_codec_context_t *context;
1018
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
1019
- assert(err == 0);
1020
-
1021
- bare_ffmpeg_packet_t *packet;
1022
- err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
1023
- assert(err == 0);
1024
-
1025
- err = avcodec_send_packet(context->handle, packet->handle);
1026
-
1027
- if (err < 0) {
1028
- err = js_throw_error(env, NULL, av_err2str(err));
1029
- assert(err == 0);
1030
- }
1031
-
1032
- return NULL;
1033
- }
1034
-
1035
- static js_value_t *
1036
- bare_ffmpeg_codec_context_receive_packet(js_env_t *env, js_callback_info_t *info) {
1037
- int err;
1038
-
1039
- size_t argc = 2;
1040
- js_value_t *argv[2];
1041
-
1042
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1043
- assert(err == 0);
1044
-
1045
- assert(argc == 2);
1046
-
1047
- bare_ffmpeg_codec_context_t *context;
1048
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
1049
- assert(err == 0);
1050
-
1051
- bare_ffmpeg_packet_t *packet;
1052
- err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
1053
- assert(err == 0);
1054
-
1055
- err = avcodec_receive_packet(context->handle, packet->handle);
1056
-
1057
- if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
1058
- err = js_throw_error(env, NULL, av_err2str(err));
1059
- assert(err == 0);
1060
-
1061
- return NULL;
1062
- }
1063
-
1064
- js_value_t *result;
1065
- err = js_get_boolean(env, err == 0, &result);
1066
- assert(err == 0);
1067
-
1068
- return result;
1069
- }
1070
-
1071
- static js_value_t *
1072
- bare_ffmpeg_codec_context_send_frame(js_env_t *env, js_callback_info_t *info) {
1073
- int err;
1074
-
1075
- size_t argc = 2;
1076
- js_value_t *argv[2];
1077
-
1078
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1079
- assert(err == 0);
1080
-
1081
- assert(argc == 2);
1082
-
1083
- bare_ffmpeg_codec_context_t *context;
1084
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
1085
- assert(err == 0);
1086
-
1087
- bare_ffmpeg_frame_t *frame;
1088
- err = js_get_arraybuffer_info(env, argv[1], (void **) &frame, NULL);
1089
- assert(err == 0);
1090
-
1091
- err = avcodec_send_frame(context->handle, frame->handle);
1092
-
1093
- if (err == AVERROR(EAGAIN) || err == AVERROR_EOF) {
1094
- js_value_t *result;
1095
- err = js_get_boolean(env, false, &result);
1096
- assert(err == 0);
1097
-
1098
- return result;
1099
- }
1100
-
1101
- if (err < 0) {
1102
- err = js_throw_error(env, NULL, av_err2str(err));
1103
- assert(err == 0);
1104
-
1105
- return NULL;
1106
- }
1107
-
1108
- js_value_t *result;
1109
- err = js_get_boolean(env, err == 0, &result);
1110
- assert(err == 0);
1111
-
1112
- return result;
1113
- }
1114
-
1115
- static js_value_t *
1116
- bare_ffmpeg_codec_context_receive_frame(js_env_t *env, js_callback_info_t *info) {
1117
- int err;
1118
-
1119
- size_t argc = 2;
1120
- js_value_t *argv[2];
1121
-
1122
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1123
- assert(err == 0);
1124
-
1125
- assert(argc == 2);
1126
-
1127
- bare_ffmpeg_codec_context_t *context;
1128
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
1129
- assert(err == 0);
1130
-
1131
- bare_ffmpeg_frame_t *frame;
1132
- err = js_get_arraybuffer_info(env, argv[1], (void **) &frame, NULL);
1133
- assert(err == 0);
1134
-
1135
- err = avcodec_receive_frame(context->handle, frame->handle);
1136
-
1137
- if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
1138
- err = js_throw_error(env, NULL, av_err2str(err));
1139
- assert(err == 0);
1140
-
1141
- return NULL;
1142
- }
1143
-
1144
- js_value_t *result;
1145
- err = js_get_boolean(env, err == 0, &result);
1146
- assert(err == 0);
1147
-
1148
- return result;
1149
- }
1150
-
1151
- static js_value_t *
1152
- bare_ffmpeg_codec_parameters_from_context(js_env_t *env, js_callback_info_t *info) {
1153
- int err;
1154
-
1155
- size_t argc = 2;
1156
- js_value_t *argv[2];
1157
-
1158
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1159
- assert(err == 0);
1160
-
1161
- assert(argc == 2);
1162
-
1163
- bare_ffmpeg_codec_parameters_t *parameters;
1164
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1165
- assert(err == 0);
1166
-
1167
- bare_ffmpeg_codec_context_t *context;
1168
- err = js_get_arraybuffer_info(env, argv[1], (void **) &context, NULL);
1169
- assert(err == 0);
1170
-
1171
- err = avcodec_parameters_from_context(parameters->handle, context->handle);
1172
-
1173
- if (err < 0) {
1174
- err = js_throw_error(env, NULL, av_err2str(err));
1175
- assert(err == 0);
1176
- }
1177
-
1178
- return NULL;
1179
- }
1180
-
1181
- static js_value_t *
1182
- bare_ffmpeg_codec_parameters_to_context(js_env_t *env, js_callback_info_t *info) {
1183
- int err;
1184
-
1185
- size_t argc = 2;
1186
- js_value_t *argv[2];
1187
-
1188
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1189
- assert(err == 0);
1190
-
1191
- assert(argc == 2);
1192
-
1193
- bare_ffmpeg_codec_context_t *context;
1194
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
1195
- assert(err == 0);
1196
-
1197
- bare_ffmpeg_codec_parameters_t *parameters;
1198
- err = js_get_arraybuffer_info(env, argv[1], (void **) &parameters, NULL);
1199
- assert(err == 0);
1200
-
1201
- err = avcodec_parameters_to_context(context->handle, parameters->handle);
1202
-
1203
- if (err < 0) {
1204
- err = js_throw_error(env, NULL, av_err2str(err));
1205
- assert(err == 0);
1206
- }
1207
-
1208
- return NULL;
1209
- }
1210
-
1211
- static js_value_t *
1212
- bare_ffmpeg_codec_parameters_get_bit_rate(js_env_t *env, js_callback_info_t *info) {
1213
- int err;
1214
-
1215
- size_t argc = 1;
1216
- js_value_t *argv[1];
1217
-
1218
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1219
- assert(err == 0);
1220
-
1221
- assert(argc == 1);
1222
-
1223
- bare_ffmpeg_codec_parameters_t *parameters;
1224
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1225
- assert(err == 0);
1226
-
1227
- js_value_t *result;
1228
- err = js_create_int64(env, parameters->handle->bit_rate, &result);
1229
- assert(err == 0);
1230
-
1231
- return result;
1232
- }
1233
-
1234
- static js_value_t *
1235
- bare_ffmpeg_codec_parameters_get_bits_per_coded_sample(js_env_t *env, js_callback_info_t *info) {
1236
- int err;
1237
-
1238
- size_t argc = 1;
1239
- js_value_t *argv[1];
1240
-
1241
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1242
- assert(err == 0);
1243
-
1244
- assert(argc == 1);
1245
-
1246
- bare_ffmpeg_codec_parameters_t *parameters;
1247
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1248
- assert(err == 0);
1249
-
1250
- js_value_t *result;
1251
- err = js_create_int64(env, parameters->handle->bits_per_coded_sample, &result);
1252
- assert(err == 0);
1253
-
1254
- return result;
1255
- }
1256
-
1257
- static js_value_t *
1258
- bare_ffmpeg_codec_parameters_get_bits_per_raw_sample(js_env_t *env, js_callback_info_t *info) {
1259
- int err;
1260
-
1261
- size_t argc = 1;
1262
- js_value_t *argv[1];
1263
-
1264
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1265
- assert(err == 0);
1266
-
1267
- assert(argc == 1);
1268
-
1269
- bare_ffmpeg_codec_parameters_t *parameters;
1270
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1271
- assert(err == 0);
1272
-
1273
- js_value_t *result;
1274
- err = js_create_int64(env, parameters->handle->bits_per_raw_sample, &result);
1275
- assert(err == 0);
1276
-
1277
- return result;
1278
- }
1279
-
1280
- static js_value_t *
1281
- bare_ffmpeg_codec_parameters_get_sample_rate(js_env_t *env, js_callback_info_t *info) {
1282
- int err;
1283
-
1284
- size_t argc = 1;
1285
- js_value_t *argv[1];
1286
-
1287
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1288
- assert(err == 0);
1289
-
1290
- assert(argc == 1);
1291
-
1292
- bare_ffmpeg_codec_parameters_t *parameters;
1293
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1294
- assert(err == 0);
1295
-
1296
- js_value_t *result;
1297
- err = js_create_int64(env, parameters->handle->sample_rate, &result);
1298
- assert(err == 0);
1299
-
1300
- return result;
1301
- }
1302
-
1303
- static js_value_t *
1304
- bare_ffmpeg_frame_init(js_env_t *env, js_callback_info_t *info) {
1305
- int err;
1306
-
1307
- js_value_t *handle;
1308
-
1309
- bare_ffmpeg_frame_t *frame;
1310
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_frame_t), (void **) &frame, &handle);
1311
- assert(err == 0);
1312
-
1313
- frame->handle = av_frame_alloc();
1314
-
1315
- frame->handle->opaque = (void *) frame;
1316
-
1317
- return handle;
1318
- }
1319
-
1320
- static js_value_t *
1321
- bare_ffmpeg_frame_destroy(js_env_t *env, js_callback_info_t *info) {
1322
- int err;
1323
-
1324
- size_t argc = 1;
1325
- js_value_t *argv[1];
1326
-
1327
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1328
- assert(err == 0);
1329
-
1330
- assert(argc == 1);
1331
-
1332
- bare_ffmpeg_frame_t *frame;
1333
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1334
- assert(err == 0);
1335
-
1336
- av_frame_free(&frame->handle);
1337
-
1338
- return NULL;
1339
- }
1340
-
1341
- static js_value_t *
1342
- bare_ffmpeg_frame_get_audio_channel(js_env_t *env, js_callback_info_t *info) {
1343
- int err;
1344
-
1345
- size_t argc = 2;
1346
- js_value_t *argv[2];
1347
-
1348
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1349
- assert(err == 0);
1350
-
1351
- assert(argc == 2);
1352
-
1353
- bare_ffmpeg_frame_t *frame;
1354
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1355
- assert(err == 0);
1356
-
1357
- uint32_t i;
1358
- err = js_get_value_uint32(env, argv[1], &i);
1359
- assert(err == 0);
1360
-
1361
- assert(i < AV_NUM_DATA_POINTERS);
1362
-
1363
- js_value_t *result;
1364
-
1365
- size_t len = frame->handle->linesize[i];
1366
-
1367
- void *data;
1368
- err = js_create_unsafe_arraybuffer(env, len, &data, &result);
1369
- assert(err == 0);
1370
-
1371
- memcpy(data, frame->handle->data[i], len);
1372
-
1373
- return result;
1374
- }
1375
-
1376
- static js_value_t *
1377
- bare_ffmpeg_frame_get_width(js_env_t *env, js_callback_info_t *info) {
1378
- int err;
1379
-
1380
- size_t argc = 1;
1381
- js_value_t *argv[1];
1382
-
1383
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1384
- assert(err == 0);
1385
-
1386
- assert(argc == 1);
1387
-
1388
- bare_ffmpeg_frame_t *frame;
1389
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1390
- assert(err == 0);
1391
-
1392
- js_value_t *result;
1393
- err = js_create_int32(env, frame->handle->width, &result);
1394
- assert(err == 0);
1395
-
1396
- return result;
1397
- }
1398
-
1399
- static js_value_t *
1400
- bare_ffmpeg_frame_set_width(js_env_t *env, js_callback_info_t *info) {
1401
- int err;
1402
-
1403
- size_t argc = 2;
1404
- js_value_t *argv[2];
1405
-
1406
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1407
- assert(err == 0);
1408
-
1409
- assert(argc == 2);
1410
-
1411
- bare_ffmpeg_frame_t *frame;
1412
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1413
- assert(err == 0);
1414
-
1415
- int32_t width;
1416
- err = js_get_value_int32(env, argv[1], &width);
1417
- assert(err == 0);
1418
-
1419
- frame->handle->width = width;
1420
-
1421
- return NULL;
1422
- }
1423
-
1424
- static js_value_t *
1425
- bare_ffmpeg_frame_get_height(js_env_t *env, js_callback_info_t *info) {
1426
- int err;
1427
-
1428
- size_t argc = 1;
1429
- js_value_t *argv[1];
1430
-
1431
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1432
- assert(err == 0);
1433
-
1434
- assert(argc == 1);
1435
-
1436
- bare_ffmpeg_frame_t *frame;
1437
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1438
- assert(err == 0);
1439
-
1440
- js_value_t *result;
1441
- err = js_create_int32(env, frame->handle->height, &result);
1442
- assert(err == 0);
1443
-
1444
- return result;
1445
- }
1446
-
1447
- static js_value_t *
1448
- bare_ffmpeg_frame_set_height(js_env_t *env, js_callback_info_t *info) {
1449
- int err;
1450
-
1451
- size_t argc = 2;
1452
- js_value_t *argv[2];
1453
-
1454
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1455
- assert(err == 0);
1456
-
1457
- assert(argc == 2);
1458
-
1459
- bare_ffmpeg_frame_t *frame;
1460
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1461
- assert(err == 0);
1462
-
1463
- int32_t height;
1464
- err = js_get_value_int32(env, argv[1], &height);
1465
- assert(err == 0);
1466
-
1467
- frame->handle->height = height;
1468
-
1469
- return NULL;
1470
- }
1471
-
1472
- static js_value_t *
1473
- bare_ffmpeg_frame_get_pixel_format(js_env_t *env, js_callback_info_t *info) {
1474
- int err;
1475
-
1476
- size_t argc = 1;
1477
- js_value_t *argv[1];
1478
-
1479
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1480
- assert(err == 0);
1481
-
1482
- assert(argc == 1);
1483
-
1484
- bare_ffmpeg_frame_t *frame;
1485
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1486
- assert(err == 0);
1487
-
1488
- js_value_t *result;
1489
- err = js_create_int64(env, frame->handle->format, &result);
1490
- assert(err == 0);
1491
-
1492
- return result;
1493
- }
1494
-
1495
- static js_value_t *
1496
- bare_ffmpeg_frame_set_pixel_format(js_env_t *env, js_callback_info_t *info) {
1497
- int err;
1498
-
1499
- size_t argc = 2;
1500
- js_value_t *argv[2];
1501
-
1502
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1503
- assert(err == 0);
1504
-
1505
- assert(argc == 2);
1506
-
1507
- bare_ffmpeg_frame_t *frame;
1508
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1509
- assert(err == 0);
1510
-
1511
- int64_t pixel_format;
1512
- err = js_get_value_int64(env, argv[1], &pixel_format);
1513
- assert(err == 0);
1514
-
1515
- frame->handle->format = (enum AVPixelFormat) pixel_format;
1516
-
1517
- return NULL;
1518
- }
1519
-
1520
- static js_value_t *
1521
- bare_ffmpeg_frame_alloc(js_env_t *env, js_callback_info_t *info) {
1522
- int err;
1523
-
1524
- size_t argc = 2;
1525
- js_value_t *argv[2];
1526
-
1527
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1528
- assert(err == 0);
1529
-
1530
- assert(argc == 2);
1531
-
1532
- bare_ffmpeg_frame_t *frame;
1533
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1534
- assert(err == 0);
1535
-
1536
- int align;
1537
- err = js_get_value_int32(env, argv[1], &align);
1538
- assert(err == 0);
1539
-
1540
- err = av_frame_get_buffer(frame->handle, align);
1541
-
1542
- if (err < 0) {
1543
- err = js_throw_error(env, NULL, av_err2str(err));
1544
- assert(err == 0);
1545
- }
1546
-
1547
- return NULL;
1548
- }
1549
-
1550
- static js_value_t *
1551
- bare_ffmpeg_image_init(js_env_t *env, js_callback_info_t *info) {
1552
- int err;
1553
-
1554
- size_t argc = 4;
1555
- js_value_t *argv[4];
1556
-
1557
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1558
- assert(err == 0);
1559
-
1560
- assert(argc == 4);
1561
-
1562
- int64_t format;
1563
- err = js_get_value_int64(env, argv[0], &format);
1564
- assert(err == 0);
1565
-
1566
- int32_t width;
1567
- err = js_get_value_int32(env, argv[1], &width);
1568
- assert(err == 0);
1569
-
1570
- int32_t height;
1571
- err = js_get_value_int32(env, argv[2], &height);
1572
- assert(err == 0);
1573
-
1574
- int32_t align;
1575
- err = js_get_value_int32(env, argv[3], &align);
1576
- assert(err == 0);
1577
-
1578
- size_t len = av_image_get_buffer_size((enum AVPixelFormat) format, width, height, align);
1579
-
1580
- js_value_t *handle;
1581
-
1582
- uint8_t *data;
1583
- err = js_create_arraybuffer(env, len, (void **) &data, &handle);
1584
- assert(err == 0);
1585
-
1586
- return handle;
1587
- }
1588
-
1589
- static js_value_t *
1590
- bare_ffmpeg_image_fill(js_env_t *env, js_callback_info_t *info) {
1591
- int err;
1592
-
1593
- size_t argc = 5;
1594
- js_value_t *argv[5];
1595
-
1596
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1597
- assert(err == 0);
1598
-
1599
- assert(argc == 5);
1600
-
1601
- int64_t pixel_format;
1602
- err = js_get_value_int64(env, argv[0], &pixel_format);
1603
- assert(err == 0);
1604
-
1605
- int32_t width;
1606
- err = js_get_value_int32(env, argv[1], &width);
1607
- assert(err == 0);
1608
-
1609
- int32_t height;
1610
- err = js_get_value_int32(env, argv[2], &height);
1611
- assert(err == 0);
1612
-
1613
- uint8_t *data;
1614
- err = js_get_arraybuffer_info(env, argv[3], (void **) &data, NULL);
1615
- assert(err == 0);
1616
-
1617
- bare_ffmpeg_frame_t *frame;
1618
- err = js_get_arraybuffer_info(env, argv[4], (void **) &frame, NULL);
1619
- assert(err == 0);
1620
-
1621
- err = av_image_fill_arrays(frame->handle->data, frame->handle->linesize, data, (enum AVPixelFormat) pixel_format, width, height, 1);
1622
- assert(err >= 0);
1623
-
1624
- return NULL;
1625
- }
1626
-
1627
- static js_value_t *
1628
- bare_ffmpeg_image_get_line_size(js_env_t *env, js_callback_info_t *info) {
1629
- int err;
1630
-
1631
- size_t argc = 3;
1632
- js_value_t *argv[3];
1633
-
1634
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1635
- assert(err == 0);
1636
-
1637
- assert(argc == 3);
1638
-
1639
- int64_t pixel_format;
1640
- err = js_get_value_int64(env, argv[0], &pixel_format);
1641
- assert(err == 0);
1642
-
1643
- int32_t width;
1644
- err = js_get_value_int32(env, argv[1], &width);
1645
- assert(err == 0);
1646
-
1647
- int32_t plane;
1648
- err = js_get_value_int32(env, argv[2], &plane);
1649
- assert(err == 0);
1650
-
1651
- int32_t linesize = av_image_get_linesize((enum AVPixelFormat) pixel_format, width, plane);
1652
-
1653
- js_value_t *result;
1654
- err = js_create_int32(env, linesize, &result);
1655
- assert(err == 0);
1656
-
1657
- return result;
1658
- }
1659
-
1660
- static js_value_t *
1661
- bare_ffmpeg_packet_init(js_env_t *env, js_callback_info_t *info) {
1662
- int err;
1663
-
1664
- js_value_t *handle;
1665
-
1666
- bare_ffmpeg_packet_t *packet;
1667
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_packet_t), (void **) &packet, &handle);
1668
- assert(err == 0);
1669
-
1670
- packet->handle = av_packet_alloc();
1671
-
1672
- return handle;
1673
- }
1674
-
1675
- static js_value_t *
1676
- bare_ffmpeg_packet_init_from_buffer(js_env_t *env, js_callback_info_t *info) {
1677
- int err;
1678
-
1679
- size_t argc = 3;
1680
- js_value_t *argv[3];
1681
-
1682
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1683
- assert(err == 0);
1684
-
1685
- assert(argc == 3);
1686
-
1687
- uint8_t *data;
1688
- err = js_get_arraybuffer_info(env, argv[0], (void **) &data, NULL);
1689
- assert(err == 0);
1690
-
1691
- uint32_t offset;
1692
- err = js_get_value_uint32(env, argv[1], &offset);
1693
- assert(err == 0);
1694
-
1695
- uint32_t len;
1696
- err = js_get_value_uint32(env, argv[2], &len);
1697
- assert(err == 0);
1698
-
1699
- AVPacket *pkt = av_packet_alloc();
1700
- assert(pkt != NULL);
1701
-
1702
- err = av_new_packet(pkt, len);
1703
- assert(err == 0);
1704
-
1705
- memcpy(pkt->data, &data[offset], len);
1706
-
1707
- js_value_t *handle;
1708
-
1709
- bare_ffmpeg_packet_t *packet;
1710
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_packet_t), (void **) &packet, &handle);
1711
- assert(err == 0);
1712
-
1713
- packet->handle = pkt;
1714
-
1715
- return handle;
1716
- }
1717
-
1718
- static js_value_t *
1719
- bare_ffmpeg_packet_destroy(js_env_t *env, js_callback_info_t *info) {
1720
- int err;
1721
-
1722
- size_t argc = 1;
1723
- js_value_t *argv[1];
1724
-
1725
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1726
- assert(err == 0);
1727
-
1728
- assert(argc == 1);
1729
-
1730
- bare_ffmpeg_packet_t *packet;
1731
- err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
1732
- assert(err == 0);
1733
-
1734
- av_packet_unref(packet->handle);
1735
-
1736
- return NULL;
1737
- }
1738
-
1739
- static js_value_t *
1740
- bare_ffmpeg_packet_unref(js_env_t *env, js_callback_info_t *info) {
1741
- int err;
1742
-
1743
- size_t argc = 1;
1744
- js_value_t *argv[1];
1745
-
1746
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1747
- assert(err == 0);
1748
-
1749
- assert(argc == 1);
1750
-
1751
- bare_ffmpeg_packet_t *packet;
1752
- err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
1753
- assert(err == 0);
1754
-
1755
- av_packet_unref(packet->handle);
1756
-
1757
- return NULL;
1758
- }
1759
-
1760
- static js_value_t *
1761
- bare_ffmpeg_packet_get_stream_index(js_env_t *env, js_callback_info_t *info) {
1762
- int err;
1763
-
1764
- size_t argc = 1;
1765
- js_value_t *argv[1];
1766
-
1767
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1768
- assert(err == 0);
1769
-
1770
- assert(argc == 1);
1771
-
1772
- bare_ffmpeg_packet_t *packet;
1773
- err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
1774
- assert(err == 0);
1775
-
1776
- js_value_t *result;
1777
- err = js_create_int32(env, packet->handle->stream_index, &result);
1778
- assert(err == 0);
1779
-
1780
- return result;
1781
- }
1782
-
1783
- static js_value_t *
1784
- bare_ffmpeg_packet_get_data(js_env_t *env, js_callback_info_t *info) {
1785
- int err;
1786
-
1787
- size_t argc = 1;
1788
- js_value_t *argv[1];
1789
-
1790
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1791
- assert(err == 0);
1792
-
1793
- assert(argc == 1);
1794
-
1795
- bare_ffmpeg_packet_t *packet;
1796
- err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
1797
- assert(err == 0);
1798
-
1799
- js_value_t *handle;
1800
-
1801
- uint8_t *data;
1802
- err = js_create_arraybuffer(env, packet->handle->size, (void **) &data, &handle);
1803
- assert(err == 0);
1804
-
1805
- memcpy(data, packet->handle->data, packet->handle->size);
1806
-
1807
- return handle;
1808
- }
1809
-
1810
- static js_value_t *
1811
- bare_ffmpeg_scaler_init(js_env_t *env, js_callback_info_t *info) {
1812
- int err;
1813
-
1814
- size_t argc = 6;
1815
- js_value_t *argv[6];
1816
-
1817
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1818
- assert(err == 0);
1819
-
1820
- assert(argc == 6);
1821
-
1822
- int64_t source_format;
1823
- err = js_get_value_int64(env, argv[0], &source_format);
1824
- assert(err == 0);
1825
-
1826
- int32_t source_width;
1827
- err = js_get_value_int32(env, argv[1], &source_width);
1828
- assert(err == 0);
1829
-
1830
- int32_t source_height;
1831
- err = js_get_value_int32(env, argv[2], &source_height);
1832
- assert(err == 0);
1833
-
1834
- int64_t target_format;
1835
- err = js_get_value_int64(env, argv[3], &target_format);
1836
- assert(err == 0);
1837
-
1838
- int32_t target_width;
1839
- err = js_get_value_int32(env, argv[4], &target_width);
1840
- assert(err == 0);
1841
-
1842
- int32_t target_height;
1843
- err = js_get_value_int32(env, argv[5], &target_height);
1844
- assert(err == 0);
1845
-
1846
- js_value_t *handle;
1847
-
1848
- bare_ffmpeg_scaler_t *scaler;
1849
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_scaler_t), (void **) &scaler, &handle);
1850
- assert(err == 0);
1851
-
1852
- scaler->handle = sws_getContext(
1853
- source_width,
1854
- source_height,
1855
- (enum AVPixelFormat) source_format,
1856
- target_width,
1857
- target_height,
1858
- (enum AVPixelFormat) target_format,
1859
- SWS_BICUBIC,
1860
- NULL,
1861
- NULL,
1862
- NULL
1863
- );
1864
-
1865
- return handle;
1866
- }
1867
-
1868
- static js_value_t *
1869
- bare_ffmpeg_scaler_destroy(js_env_t *env, js_callback_info_t *info) {
1870
- int err;
1871
-
1872
- size_t argc = 1;
1873
- js_value_t *argv[1];
1874
-
1875
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1876
- assert(err == 0);
1877
-
1878
- assert(argc == 1);
1879
-
1880
- bare_ffmpeg_scaler_t *scaler;
1881
- err = js_get_arraybuffer_info(env, argv[0], (void **) &scaler, NULL);
1882
- assert(err == 0);
1883
-
1884
- sws_freeContext(scaler->handle);
1885
-
1886
- return NULL;
1887
- }
1888
-
1889
- static js_value_t *
1890
- bare_ffmpeg_scaler_scale(js_env_t *env, js_callback_info_t *info) {
1891
- int err;
1892
-
1893
- size_t argc = 5;
1894
- js_value_t *argv[5];
1895
-
1896
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1897
- assert(err == 0);
1898
-
1899
- assert(argc == 5);
1900
-
1901
- bare_ffmpeg_scaler_t *scaler;
1902
- err = js_get_arraybuffer_info(env, argv[0], (void **) &scaler, NULL);
1903
- assert(err == 0);
1904
-
1905
- bare_ffmpeg_frame_t *source;
1906
- err = js_get_arraybuffer_info(env, argv[1], (void **) &source, NULL);
1907
- assert(err == 0);
1908
-
1909
- int64_t y;
1910
- err = js_get_value_int64(env, argv[2], &y);
1911
- assert(err == 0);
1912
-
1913
- int64_t height;
1914
- err = js_get_value_int64(env, argv[3], &height);
1915
- assert(err == 0);
1916
-
1917
- bare_ffmpeg_frame_t *target;
1918
- err = js_get_arraybuffer_info(env, argv[4], (void **) &target, NULL);
1919
- assert(err == 0);
1920
-
1921
- height = sws_scale(
1922
- scaler->handle,
1923
- (const uint8_t *const *) source->handle->data,
1924
- source->handle->linesize,
1925
- y,
1926
- height,
1927
- target->handle->data,
1928
- target->handle->linesize
1929
- );
1930
-
1931
- js_value_t *result;
1932
- err = js_create_int64(env, height, &result);
1933
- assert(err == 0);
1934
-
1935
- return result;
1936
- }
1937
-
1938
- static js_value_t *
1939
- bare_ffmpeg_dictionary_init(js_env_t *env, js_callback_info_t *info) {
1940
- int err;
1941
- js_value_t *handle;
1942
-
1943
- bare_ffmpeg_dictionary_t *dict;
1944
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_dictionary_t), (void **) &dict, &handle);
1945
- assert(err == 0);
1946
-
1947
- dict->handle = NULL;
1948
-
1949
- return handle;
1950
- }
1951
-
1952
- static js_value_t *
1953
- bare_ffmpeg_dictionary_destroy(js_env_t *env, js_callback_info_t *info) {
1954
- int err;
1955
-
1956
- size_t argc = 1;
1957
- js_value_t *argv[1];
1958
-
1959
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1960
- assert(err == 0);
1961
-
1962
- assert(argc == 1);
1963
-
1964
- bare_ffmpeg_dictionary_t *dict;
1965
- err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
1966
- assert(err == 0);
1967
-
1968
- av_dict_free(&dict->handle);
1969
-
1970
- return NULL;
1971
- }
1972
-
1973
- static js_value_t *
1974
- bare_ffmpeg_dictionary_set_entry(js_env_t *env, js_callback_info_t *info) {
1975
- int err;
1976
-
1977
- size_t argc = 3;
1978
- js_value_t *argv[3];
1979
-
1980
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1981
- assert(err == 0);
1982
-
1983
- assert(argc == 3);
1984
-
1985
- bare_ffmpeg_dictionary_t *dict;
1986
- err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
1987
- assert(err == 0);
1988
-
1989
- size_t len;
1990
- err = js_get_value_string_utf8(env, argv[1], NULL, 0, &len);
1991
- assert(err == 0);
1992
-
1993
- len += +1 /* NULL */;
1994
-
1995
- utf8_t *key = malloc(len);
1996
- err = js_get_value_string_utf8(env, argv[1], key, len, NULL);
1997
- assert(err == 0);
1998
-
1999
- err = js_get_value_string_utf8(env, argv[2], NULL, 0, &len);
2000
- assert(err == 0);
2001
-
2002
- len += +1 /* NULL */;
2003
-
2004
- utf8_t *value = malloc(len);
2005
- err = js_get_value_string_utf8(env, argv[2], value, len, NULL);
2006
- assert(err == 0);
2007
-
2008
- err = av_dict_set(&dict->handle, (const char *) key, (const char *) value, 0);
2009
- assert(err == 0);
2010
-
2011
- free(key);
2012
- free(value);
2013
-
2014
- return NULL;
2015
- }
2016
-
2017
- static js_value_t *
2018
- bare_ffmpeg_dictionary_get_entry(js_env_t *env, js_callback_info_t *info) {
2019
- int err;
2020
-
2021
- size_t argc = 2;
2022
- js_value_t *argv[2];
2023
-
2024
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
2025
- assert(err == 0);
2026
-
2027
- assert(argc == 2);
2028
-
2029
- bare_ffmpeg_dictionary_t *dict;
2030
- err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
2031
- assert(err == 0);
2032
-
2033
- size_t len;
2034
- err = js_get_value_string_utf8(env, argv[1], NULL, 0, &len);
2035
- assert(err == 0);
2036
-
2037
- len += +1 /* NULL */;
2038
-
2039
- utf8_t *key = malloc(len);
2040
- err = js_get_value_string_utf8(env, argv[1], key, len, NULL);
2041
- assert(err == 0);
2042
-
2043
- AVDictionaryEntry *entry = av_dict_get(dict->handle, (const char *) key, NULL, 0);
2044
-
2045
- free(key);
2046
-
2047
- if (entry == NULL) {
2048
- js_value_t *result;
2049
- err = js_get_null(env, &result);
2050
- assert(err == 0);
2051
-
2052
- return result;
2053
- }
2054
-
2055
- js_value_t *result;
2056
- err = js_create_string_utf8(env, (const utf8_t *) entry->value, -1, &result);
2057
- assert(err == 0);
2058
-
2059
- return result;
2060
- }
2061
-
2062
- static js_value_t *
2063
- bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
2064
- uv_once(&bare_ffmpeg__init_guard, bare_ffmpeg__on_init);
2065
-
2066
- int err;
2067
-
2068
- #define V(name, fn) \
2069
- { \
2070
- js_value_t *val; \
2071
- err = js_create_function(env, name, -1, fn, NULL, &val); \
2072
- assert(err == 0); \
2073
- err = js_set_named_property(env, exports, name, val); \
2074
- assert(err == 0); \
2075
- }
2076
-
2077
- V("initIOContext", bare_ffmpeg_io_context_init)
2078
- V("destroyIOContext", bare_ffmpeg_io_context_destroy)
2079
-
2080
- V("initOutputFormat", bare_ffmpeg_output_format_init)
2081
- V("initInputFormat", bare_ffmpeg_input_format_init)
2082
-
2083
- V("openInputFormatContextWithIO", bare_ffmpeg_format_context_open_input_with_io)
2084
- V("openInputFormatContextWithFormat", bare_ffmpeg_format_context_open_input_with_format)
2085
- V("closeInputFormatContext", bare_ffmpeg_format_context_close_input)
2086
- V("openOutputFormatContext", bare_ffmpeg_format_context_open_output)
2087
- V("closeOutputFormatContext", bare_ffmpeg_format_context_close_output)
2088
- V("getFormatContextStreams", bare_ffmpeg_format_context_get_streams)
2089
- V("getFormatContextBestStreamIndex", bare_ffmpeg_format_context_get_best_stream_index)
2090
- V("createFormatContextStream", bare_ffmpeg_format_context_create_stream)
2091
- V("readFormatContextFrame", bare_ffmpeg_format_context_read_frame)
2092
-
2093
- V("getStreamCodec", bare_ffmpeg_stream_get_codec)
2094
- V("getStreamCodecParameters", bare_ffmpeg_stream_get_codec_parameters)
2095
-
2096
- V("findDecoderByID", bare_ffmpeg_find_decoder_by_id)
2097
- V("findEncoderByID", bare_ffmpeg_find_encoder_by_id)
2098
-
2099
- V("initCodecContext", bare_ffmpeg_codec_context_init)
2100
- V("destroyCodecContext", bare_ffmpeg_codec_context_destroy)
2101
- V("openCodecContext", bare_ffmpeg_codec_context_open)
2102
- V("openCodecContextWithOptions", bare_ffmpeg_codec_context_open_with_options)
2103
- V("getCodecContextPixelFormat", bare_ffmpeg_codec_context_get_pixel_format)
2104
- V("setCodecContextPixelFormat", bare_ffmpeg_codec_context_set_pixel_format)
2105
- V("getCodecContextWidth", bare_ffmpeg_codec_context_get_width)
2106
- V("setCodecContextWidth", bare_ffmpeg_codec_context_set_width)
2107
- V("getCodecContextHeight", bare_ffmpeg_codec_context_get_height)
2108
- V("setCodecContextHeight", bare_ffmpeg_codec_context_set_height)
2109
- V("getCodecContextTimeBase", bare_ffmpeg_codec_context_get_time_base)
2110
- V("setCodecContextTimeBase", bare_ffmpeg_codec_context_set_time_base)
2111
- V("sendCodecContextPacket", bare_ffmpeg_codec_context_send_packet)
2112
- V("receiveCodecContextPacket", bare_ffmpeg_codec_context_receive_packet)
2113
- V("sendCodecContextFrame", bare_ffmpeg_codec_context_send_frame)
2114
- V("receiveCodecContextFrame", bare_ffmpeg_codec_context_receive_frame)
2115
-
2116
- V("codecParametersFromContext", bare_ffmpeg_codec_parameters_from_context)
2117
- V("codecParametersToContext", bare_ffmpeg_codec_parameters_to_context)
2118
- V("getCodecParametersBitRate", bare_ffmpeg_codec_parameters_get_bit_rate)
2119
- V("getCodecParametersBitsPerCodedSample", bare_ffmpeg_codec_parameters_get_bits_per_coded_sample)
2120
- V("getCodecParametersBitsPerRawSample", bare_ffmpeg_codec_parameters_get_bits_per_raw_sample)
2121
- V("getCodecParametersSampleRate", bare_ffmpeg_codec_parameters_get_sample_rate)
2122
-
2123
- V("initFrame", bare_ffmpeg_frame_init)
2124
- V("destroyFrame", bare_ffmpeg_frame_destroy)
2125
- V("getFrameAudioChannel", bare_ffmpeg_frame_get_audio_channel)
2126
- V("getFrameWidth", bare_ffmpeg_frame_get_width)
2127
- V("setFrameWidth", bare_ffmpeg_frame_set_width)
2128
- V("getFrameHeight", bare_ffmpeg_frame_get_height)
2129
- V("setFrameHeight", bare_ffmpeg_frame_set_height)
2130
- V("getFramePixelFormat", bare_ffmpeg_frame_get_pixel_format)
2131
- V("setFramePixelFormat", bare_ffmpeg_frame_set_pixel_format)
2132
- V("allocFrame", bare_ffmpeg_frame_alloc)
2133
-
2134
- V("initImage", bare_ffmpeg_image_init)
2135
- V("fillImage", bare_ffmpeg_image_fill)
2136
- V("getImageLineSize", bare_ffmpeg_image_get_line_size)
2137
-
2138
- V("initPacket", bare_ffmpeg_packet_init)
2139
- V("initPacketFromBuffer", bare_ffmpeg_packet_init_from_buffer)
2140
- V("destroyPacket", bare_ffmpeg_packet_destroy)
2141
- V("unrefPacket", bare_ffmpeg_packet_unref)
2142
- V("getPacketStreamIndex", bare_ffmpeg_packet_get_stream_index)
2143
- V("getPacketData", bare_ffmpeg_packet_get_data)
2144
-
2145
- V("initScaler", bare_ffmpeg_scaler_init)
2146
- V("destroyScaler", bare_ffmpeg_scaler_destroy)
2147
- V("scaleScaler", bare_ffmpeg_scaler_scale)
2148
-
2149
- V("initDictionary", bare_ffmpeg_dictionary_init)
2150
- V("destroyDictionary", bare_ffmpeg_dictionary_destroy)
2151
- V("getDictionaryEntry", bare_ffmpeg_dictionary_get_entry)
2152
- V("setDictionaryEntry", bare_ffmpeg_dictionary_set_entry)
2153
- #undef V
2154
-
2155
- #define V(name) \
2156
- { \
2157
- js_value_t *val; \
2158
- err = js_create_int64(env, name, &val); \
2159
- assert(err == 0); \
2160
- err = js_set_named_property(env, exports, #name, val); \
2161
- assert(err == 0); \
2162
- }
2163
-
2164
- V(AV_CODEC_ID_MJPEG)
2165
- V(AV_CODEC_ID_H264)
2166
-
2167
- V(AV_PIX_FMT_RGBA)
2168
- V(AV_PIX_FMT_RGB24)
2169
- V(AV_PIX_FMT_YUVJ420P)
2170
- V(AV_PIX_FMT_YUV420P)
2171
-
2172
- V(AVMEDIA_TYPE_UNKNOWN)
2173
- V(AVMEDIA_TYPE_VIDEO)
2174
- V(AVMEDIA_TYPE_AUDIO)
2175
- V(AVMEDIA_TYPE_DATA)
2176
- V(AVMEDIA_TYPE_SUBTITLE)
2177
- V(AVMEDIA_TYPE_ATTACHMENT)
2178
- V(AVMEDIA_TYPE_NB)
2179
- #undef V
2180
-
2181
- return exports;
2182
- }
2183
-
2184
- BARE_MODULE(bare_ffmpeg, bare_ffmpeg_exports)